def to(self, value, unit2: str, unit_type: str = None): # pylint: disable=invalid-name
"""Quickly convert based on variable name"""
# Stopping condition
if not self.is_quick_convert_possible:
raise MinimumPythonVersionNotMet(8)
unit1 = argname("value").split("_")[-1]
converted_value = self.convert(value, unit1, unit2, unit_type)
return converted_value
def __init__(self, *none_args):
self.warning = "Supplied arguments with None value:"
names = argname(none_args)
for index, name in enumerate(names):
last_index = (len(names) - 1)
if index == last_index:
self.warning += f" {name}"
else:
self.warning += f" {name},"
super().__init__(self.warning)
def not_none(*args):
"""
Check that all its arguments are not None otherwise raise SomeArgumentHasNoneValue exception
Raise:
SomeArgumentHasNoneValue: Error if some arguments have None as value
"""
someNone = False
none_args = []
names = argname(args)
for name, arg in zip(names, args):
if arg is None:
someNone = True
#cmd2.Cmd.pwarning(f"{name} variable is None")
none_args.append(arg)
if someNone:
raise SomeArgumentHasNoneValue(*none_args)
def setting_flag(variable: Any, assign=True, name=None) -> List[str]:
"""skip if none"""
if variable is None or (not variable and isinstance(variable, (str))):
return []
if not name:
name = argname("variable")
assert isinstance(name, str)
if not isinstance(variable, (list, tuple)):
variable = [variable]
flags = []
for v in variable:
if v:
flag = "--" + (name.replace("_", "-"))
if isinstance(v, bool):
flags.append(flag)
elif assign:
flags.append(flag + "=" + str(v))
else:
flags += [flag, v]
return flags
def some_not_none(*args):
"""
Check if there is an argument not None otherwise raise AllArgumentsHaveNoneValue exception
Raise:
AllArgumentsHaveNoneValue: Error if all arguments are None
"""
#import pdb; pdb.set_trace()
someNotNone = False
none_args = []
names = argname(args)
for name, arg in zip(names, args):
if arg is not None:
someNotNone = True
else:
#cmd2.Cmd.pwarning(f"{name} variable is None")
none_args.append(arg)
if not someNotNone: #all supplied argument are None
raise AllArgumentsHaveNoneValue(*noneArgs)
def __init__(self, val, *, name: str = "") -> None:
f_info = getouterframes(currentframe())[1]
self.p_line = (f_info.filename, f_info.lineno)
self.p_locals: Dict[str, Any] = f_info.frame.f_locals
self.p_globals: Dict[str, Any] = f_info.frame.f_globals
if (not name) and argname:
try:
self.p_varname = argname(val, vars_only=False) # type: str
except Exception:
self.p_varname = name
else:
self.p_varname = name
self._with_attr: bool = False
if not self.p_varname.isidentifier():
temp: Tuple[str] = tuple(self.p_varname.split("."))
if not all(i.isidentifier() for i in temp):
self._attrs = () # type: tuple[str]
else:
self._with_attr = True
self.p_varname = temp[0]
self._attrs = temp[1:]
def well(tray, well, quality, old_df=None, **kwargs):
"""
Add one or more rows to a dataframe of crystal hits
Parameters
----------
tray : dict
Tray, as created by traytable.tray()
well : string or list of strings
Well name(s), in format '[letter][number]'
quality : string
Short categorical description, e.g. "good" or "needles"
old_df : pandas.core.frame.DataFrame, optional
Working dataframe to append to. If None, creates a new dataframe.
**kwargs : any type
Any additional named arguments will become columns in the dataframe
Raises
------
TypeError
Improper type for well name
ValueError
Row or column specified by 'well' is out of the range specified by tray['maxwell']
Returns
-------
df : pandas.core.frame.DataFrame
Dataframe containing the new reults, optionally concatenated with old_df
"""
fancy_dates = 0
statics = deepcopy(tray['statics'])
if 'date' in statics.keys():
fancy_dates += 1
statics['date_set'] = statics.pop('date')
try:
set_date = datetime.date.fromisoformat(statics['date_set'])
except ValueError:
fancy_dates -= 1
pass
if 'date' in kwargs.keys():
fancy_dates += 1
kwargs['date_logged'] = kwargs.pop('date')
try:
log_date = datetime.date.fromisoformat(kwargs['date_logged'])
except ValueError:
fancy_dates -= 1
pass
df = pd.DataFrame(columns=[tray["row"]] + [tray["col"]] + ["quality"] +
list(statics.keys()) + ["tray"] + ["well"])
if type(well) == str:
well = [well]
if type(well) != list:
raise TypeError("Improper type for well name")
for w in well:
if (w[0] not in string.ascii_uppercase[:string.ascii_uppercase.
find(tray["maxwell"][0]) + 1]):
raise ValueError(
f"Improper column specification: column is {w[0]}, should be one of {string.ascii_uppercase[:string.ascii_uppercase.find(tray['maxwell'][0])+1]}"
)
if int(w[1]) not in range(1, int(tray["maxwell"][1]) + 1):
raise ValueError(
f"Improper row specification: row is {w[1]}, should be one of {list(range(1,int(tray['maxwell'][1])+1))}"
)
df.loc[len(
df.index)] = ([tray[w[0]]] + [tray[w[1]]] + [quality] +
list(statics.values()) + [argname(tray)] + [w])
if kwargs is not None:
for key, value in kwargs.items():
df[key] = value
if fancy_dates == 2:
df['days_elapsed'] = (log_date - set_date).days
if old_df is not None:
df = pd.concat([old_df, df], axis=0, ignore_index=True)
return df
def read_rockmaker(tray, filename=None, path=".", score_dict=None, old_df=None):
"""
Import crystal hits via a RockMaker-style csv file
Parameters
----------
tray : dict
The tray, produced by tt.tray, for which you are logging hits.
filename : string, optional
The name of the csv file. Defaults to "Score Report - {tray name}.csv"
path : string, optional
Filepath to the csv file, if not in the current directory
score_dict : dict, optional
If None (default), scores are left as integers 1-9. If "rockmaker", integers are converted via the rockmaker naming convention.
Any other dictionary can be passed and used to convert integer scores as desired.
olf_df : pandas.core.frame.DataFrame, optional
Dataframe to which results should be appended
Returns
-------
screen : dict
A dictionary containing the screen
"""
if filename is None:
temp = argname(tray)
filename = f"Score Report - {temp}.csv"
data = pd.read_csv(f"{path}/{filename}")
data.rename(
columns={
"Well": "well",
"Inspection Date": "date_logged",
"Score Hotkey": "quality",
},
inplace=True,
)
data.drop(
["Well Ingredients", "Drop #", "Plate ID", "Default"], axis=1, inplace=True
)
data["tray"] = argname(tray)
data["date_logged"] = pd.to_datetime(
data["date_logged"], infer_datetime_format=True
)
data["wellrow"] = data.well.str.get(0)
data[tray["row"]] = data["wellrow"].map(tray)
data["wellcol"] = data.well.str.get(1)
data[tray["col"]] = data["wellcol"].map(tray)
data.drop(["wellrow", "wellcol"], axis=1, inplace=True)
statics = deepcopy(tray["statics"])
# special handling of dates
if "date" in statics.keys():
isodate = True
statics["date_set"] = statics.pop("date")
try:
data["date_set"] = pd.Timestamp(statics.pop("date_set"))
except ValueError:
data["date_set"] = statics.pop("date_set")
isodate = False
pass
if isodate:
data["days_elapsed"] = (data["date_logged"] - data["date_set"]).dt.days
for key, value in statics.items():
data[key] = value
if score_dict is not None:
if score_dict == "rockmaker":
score_dict = {
0: "Clear",
1: "Dust",
2: "Granular Precipitate",
3: "Full Precipitate",
4: "Good Precipitate",
5: "Phase Separation",
6: "Microcrystalline",
7: "Needles",
8: "Plates",
9: "Crystals",
}
data["quality"] = data["quality"].map(score_dict)
if old_df is not None:
data = pd.concat([old_df, data], axis=0, ignore_index=True)
return data