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