repo stringlengths 7 55 | path stringlengths 4 127 | func_name stringlengths 1 88 | original_string stringlengths 75 19.8k | language stringclasses 1 value | code stringlengths 75 19.8k | code_tokens listlengths 20 707 | docstring stringlengths 3 17.3k | docstring_tokens listlengths 3 222 | sha stringlengths 40 40 | url stringlengths 87 242 | partition stringclasses 1 value | idx int64 0 252k |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
sepandhaghighi/pycm | pycm/pycm_overall_func.py | cross_entropy_calc | def cross_entropy_calc(TOP, P, POP):
"""
Calculate cross entropy.
:param TOP: test outcome positive
:type TOP : dict
:param P: condition positive
:type P : dict
:param POP: population
:type POP : dict
:return: cross entropy as float
"""
try:
result = 0
for i in TOP.keys():
reference_likelihood = P[i] / POP[i]
response_likelihood = TOP[i] / POP[i]
if response_likelihood != 0 and reference_likelihood != 0:
result += reference_likelihood * \
math.log(response_likelihood, 2)
return -result
except Exception:
return "None" | python | def cross_entropy_calc(TOP, P, POP):
"""
Calculate cross entropy.
:param TOP: test outcome positive
:type TOP : dict
:param P: condition positive
:type P : dict
:param POP: population
:type POP : dict
:return: cross entropy as float
"""
try:
result = 0
for i in TOP.keys():
reference_likelihood = P[i] / POP[i]
response_likelihood = TOP[i] / POP[i]
if response_likelihood != 0 and reference_likelihood != 0:
result += reference_likelihood * \
math.log(response_likelihood, 2)
return -result
except Exception:
return "None" | [
"def",
"cross_entropy_calc",
"(",
"TOP",
",",
"P",
",",
"POP",
")",
":",
"try",
":",
"result",
"=",
"0",
"for",
"i",
"in",
"TOP",
".",
"keys",
"(",
")",
":",
"reference_likelihood",
"=",
"P",
"[",
"i",
"]",
"/",
"POP",
"[",
"i",
"]",
"response_li... | Calculate cross entropy.
:param TOP: test outcome positive
:type TOP : dict
:param P: condition positive
:type P : dict
:param POP: population
:type POP : dict
:return: cross entropy as float | [
"Calculate",
"cross",
"entropy",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_overall_func.py#L327-L349 | train | 231,100 |
sepandhaghighi/pycm | pycm/pycm_overall_func.py | joint_entropy_calc | def joint_entropy_calc(classes, table, POP):
"""
Calculate joint entropy.
:param classes: confusion matrix classes
:type classes : list
:param table: confusion matrix table
:type table : dict
:param POP: population
:type POP : dict
:return: joint entropy as float
"""
try:
result = 0
for i in classes:
for index, j in enumerate(classes):
p_prime = table[i][j] / POP[i]
if p_prime != 0:
result += p_prime * math.log(p_prime, 2)
return -result
except Exception:
return "None" | python | def joint_entropy_calc(classes, table, POP):
"""
Calculate joint entropy.
:param classes: confusion matrix classes
:type classes : list
:param table: confusion matrix table
:type table : dict
:param POP: population
:type POP : dict
:return: joint entropy as float
"""
try:
result = 0
for i in classes:
for index, j in enumerate(classes):
p_prime = table[i][j] / POP[i]
if p_prime != 0:
result += p_prime * math.log(p_prime, 2)
return -result
except Exception:
return "None" | [
"def",
"joint_entropy_calc",
"(",
"classes",
",",
"table",
",",
"POP",
")",
":",
"try",
":",
"result",
"=",
"0",
"for",
"i",
"in",
"classes",
":",
"for",
"index",
",",
"j",
"in",
"enumerate",
"(",
"classes",
")",
":",
"p_prime",
"=",
"table",
"[",
... | Calculate joint entropy.
:param classes: confusion matrix classes
:type classes : list
:param table: confusion matrix table
:type table : dict
:param POP: population
:type POP : dict
:return: joint entropy as float | [
"Calculate",
"joint",
"entropy",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_overall_func.py#L352-L373 | train | 231,101 |
sepandhaghighi/pycm | pycm/pycm_overall_func.py | conditional_entropy_calc | def conditional_entropy_calc(classes, table, P, POP):
"""
Calculate conditional entropy.
:param classes: confusion matrix classes
:type classes : list
:param table: confusion matrix table
:type table : dict
:param P: condition positive
:type P : dict
:param POP: population
:type POP : dict
:return: conditional entropy as float
"""
try:
result = 0
for i in classes:
temp = 0
for index, j in enumerate(classes):
p_prime = 0
if P[i] != 0:
p_prime = table[i][j] / P[i]
if p_prime != 0:
temp += p_prime * math.log(p_prime, 2)
result += temp * (P[i] / POP[i])
return -result
except Exception:
return "None" | python | def conditional_entropy_calc(classes, table, P, POP):
"""
Calculate conditional entropy.
:param classes: confusion matrix classes
:type classes : list
:param table: confusion matrix table
:type table : dict
:param P: condition positive
:type P : dict
:param POP: population
:type POP : dict
:return: conditional entropy as float
"""
try:
result = 0
for i in classes:
temp = 0
for index, j in enumerate(classes):
p_prime = 0
if P[i] != 0:
p_prime = table[i][j] / P[i]
if p_prime != 0:
temp += p_prime * math.log(p_prime, 2)
result += temp * (P[i] / POP[i])
return -result
except Exception:
return "None" | [
"def",
"conditional_entropy_calc",
"(",
"classes",
",",
"table",
",",
"P",
",",
"POP",
")",
":",
"try",
":",
"result",
"=",
"0",
"for",
"i",
"in",
"classes",
":",
"temp",
"=",
"0",
"for",
"index",
",",
"j",
"in",
"enumerate",
"(",
"classes",
")",
"... | Calculate conditional entropy.
:param classes: confusion matrix classes
:type classes : list
:param table: confusion matrix table
:type table : dict
:param P: condition positive
:type P : dict
:param POP: population
:type POP : dict
:return: conditional entropy as float | [
"Calculate",
"conditional",
"entropy",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_overall_func.py#L376-L403 | train | 231,102 |
sepandhaghighi/pycm | pycm/pycm_overall_func.py | lambda_B_calc | def lambda_B_calc(classes, table, TOP, POP):
"""
Calculate Goodman and Kruskal's lambda B.
:param classes: confusion matrix classes
:type classes : list
:param table: confusion matrix table
:type table : dict
:param TOP: test outcome positive
:type TOP : dict
:param POP: population
:type POP : int
:return: Goodman and Kruskal's lambda B as float
"""
try:
result = 0
length = POP
maxresponse = max(list(TOP.values()))
for i in classes:
result += max(list(table[i].values()))
result = (result - maxresponse) / (length - maxresponse)
return result
except Exception:
return "None" | python | def lambda_B_calc(classes, table, TOP, POP):
"""
Calculate Goodman and Kruskal's lambda B.
:param classes: confusion matrix classes
:type classes : list
:param table: confusion matrix table
:type table : dict
:param TOP: test outcome positive
:type TOP : dict
:param POP: population
:type POP : int
:return: Goodman and Kruskal's lambda B as float
"""
try:
result = 0
length = POP
maxresponse = max(list(TOP.values()))
for i in classes:
result += max(list(table[i].values()))
result = (result - maxresponse) / (length - maxresponse)
return result
except Exception:
return "None" | [
"def",
"lambda_B_calc",
"(",
"classes",
",",
"table",
",",
"TOP",
",",
"POP",
")",
":",
"try",
":",
"result",
"=",
"0",
"length",
"=",
"POP",
"maxresponse",
"=",
"max",
"(",
"list",
"(",
"TOP",
".",
"values",
"(",
")",
")",
")",
"for",
"i",
"in",... | Calculate Goodman and Kruskal's lambda B.
:param classes: confusion matrix classes
:type classes : list
:param table: confusion matrix table
:type table : dict
:param TOP: test outcome positive
:type TOP : dict
:param POP: population
:type POP : int
:return: Goodman and Kruskal's lambda B as float | [
"Calculate",
"Goodman",
"and",
"Kruskal",
"s",
"lambda",
"B",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_overall_func.py#L446-L469 | train | 231,103 |
sepandhaghighi/pycm | pycm/pycm_overall_func.py | lambda_A_calc | def lambda_A_calc(classes, table, P, POP):
"""
Calculate Goodman and Kruskal's lambda A.
:param classes: confusion matrix classes
:type classes : list
:param table: confusion matrix table
:type table : dict
:param P: condition positive
:type P : dict
:param POP: population
:type POP : int
:return: Goodman and Kruskal's lambda A as float
"""
try:
result = 0
maxreference = max(list(P.values()))
length = POP
for i in classes:
col = []
for col_item in table.values():
col.append(col_item[i])
result += max(col)
result = (result - maxreference) / (length - maxreference)
return result
except Exception:
return "None" | python | def lambda_A_calc(classes, table, P, POP):
"""
Calculate Goodman and Kruskal's lambda A.
:param classes: confusion matrix classes
:type classes : list
:param table: confusion matrix table
:type table : dict
:param P: condition positive
:type P : dict
:param POP: population
:type POP : int
:return: Goodman and Kruskal's lambda A as float
"""
try:
result = 0
maxreference = max(list(P.values()))
length = POP
for i in classes:
col = []
for col_item in table.values():
col.append(col_item[i])
result += max(col)
result = (result - maxreference) / (length - maxreference)
return result
except Exception:
return "None" | [
"def",
"lambda_A_calc",
"(",
"classes",
",",
"table",
",",
"P",
",",
"POP",
")",
":",
"try",
":",
"result",
"=",
"0",
"maxreference",
"=",
"max",
"(",
"list",
"(",
"P",
".",
"values",
"(",
")",
")",
")",
"length",
"=",
"POP",
"for",
"i",
"in",
... | Calculate Goodman and Kruskal's lambda A.
:param classes: confusion matrix classes
:type classes : list
:param table: confusion matrix table
:type table : dict
:param P: condition positive
:type P : dict
:param POP: population
:type POP : int
:return: Goodman and Kruskal's lambda A as float | [
"Calculate",
"Goodman",
"and",
"Kruskal",
"s",
"lambda",
"A",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_overall_func.py#L472-L498 | train | 231,104 |
sepandhaghighi/pycm | pycm/pycm_overall_func.py | chi_square_calc | def chi_square_calc(classes, table, TOP, P, POP):
"""
Calculate chi-squared.
:param classes: confusion matrix classes
:type classes : list
:param table: confusion matrix table
:type table : dict
:param TOP: test outcome positive
:type TOP : dict
:param P: condition positive
:type P : dict
:param POP: population
:type POP : dict
:return: chi-squared as float
"""
try:
result = 0
for i in classes:
for index, j in enumerate(classes):
expected = (TOP[j] * P[i]) / (POP[i])
result += ((table[i][j] - expected)**2) / expected
return result
except Exception:
return "None" | python | def chi_square_calc(classes, table, TOP, P, POP):
"""
Calculate chi-squared.
:param classes: confusion matrix classes
:type classes : list
:param table: confusion matrix table
:type table : dict
:param TOP: test outcome positive
:type TOP : dict
:param P: condition positive
:type P : dict
:param POP: population
:type POP : dict
:return: chi-squared as float
"""
try:
result = 0
for i in classes:
for index, j in enumerate(classes):
expected = (TOP[j] * P[i]) / (POP[i])
result += ((table[i][j] - expected)**2) / expected
return result
except Exception:
return "None" | [
"def",
"chi_square_calc",
"(",
"classes",
",",
"table",
",",
"TOP",
",",
"P",
",",
"POP",
")",
":",
"try",
":",
"result",
"=",
"0",
"for",
"i",
"in",
"classes",
":",
"for",
"index",
",",
"j",
"in",
"enumerate",
"(",
"classes",
")",
":",
"expected",... | Calculate chi-squared.
:param classes: confusion matrix classes
:type classes : list
:param table: confusion matrix table
:type table : dict
:param TOP: test outcome positive
:type TOP : dict
:param P: condition positive
:type P : dict
:param POP: population
:type POP : dict
:return: chi-squared as float | [
"Calculate",
"chi",
"-",
"squared",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_overall_func.py#L501-L525 | train | 231,105 |
sepandhaghighi/pycm | pycm/pycm_overall_func.py | kappa_se_calc | def kappa_se_calc(PA, PE, POP):
"""
Calculate kappa standard error.
:param PA: observed agreement among raters (overall accuracy)
:type PA : float
:param PE: hypothetical probability of chance agreement (random accuracy)
:type PE : float
:param POP: population
:type POP:int
:return: kappa standard error as float
"""
try:
result = math.sqrt((PA * (1 - PA)) / (POP * ((1 - PE)**2)))
return result
except Exception:
return "None" | python | def kappa_se_calc(PA, PE, POP):
"""
Calculate kappa standard error.
:param PA: observed agreement among raters (overall accuracy)
:type PA : float
:param PE: hypothetical probability of chance agreement (random accuracy)
:type PE : float
:param POP: population
:type POP:int
:return: kappa standard error as float
"""
try:
result = math.sqrt((PA * (1 - PA)) / (POP * ((1 - PE)**2)))
return result
except Exception:
return "None" | [
"def",
"kappa_se_calc",
"(",
"PA",
",",
"PE",
",",
"POP",
")",
":",
"try",
":",
"result",
"=",
"math",
".",
"sqrt",
"(",
"(",
"PA",
"*",
"(",
"1",
"-",
"PA",
")",
")",
"/",
"(",
"POP",
"*",
"(",
"(",
"1",
"-",
"PE",
")",
"**",
"2",
")",
... | Calculate kappa standard error.
:param PA: observed agreement among raters (overall accuracy)
:type PA : float
:param PE: hypothetical probability of chance agreement (random accuracy)
:type PE : float
:param POP: population
:type POP:int
:return: kappa standard error as float | [
"Calculate",
"kappa",
"standard",
"error",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_overall_func.py#L591-L607 | train | 231,106 |
sepandhaghighi/pycm | pycm/pycm_overall_func.py | micro_calc | def micro_calc(TP, item):
"""
Calculate PPV_Micro and TPR_Micro.
:param TP: true positive
:type TP:dict
:param item: FN or FP
:type item : dict
:return: PPV_Micro or TPR_Micro as float
"""
try:
TP_sum = sum(TP.values())
item_sum = sum(item.values())
return TP_sum / (TP_sum + item_sum)
except Exception:
return "None" | python | def micro_calc(TP, item):
"""
Calculate PPV_Micro and TPR_Micro.
:param TP: true positive
:type TP:dict
:param item: FN or FP
:type item : dict
:return: PPV_Micro or TPR_Micro as float
"""
try:
TP_sum = sum(TP.values())
item_sum = sum(item.values())
return TP_sum / (TP_sum + item_sum)
except Exception:
return "None" | [
"def",
"micro_calc",
"(",
"TP",
",",
"item",
")",
":",
"try",
":",
"TP_sum",
"=",
"sum",
"(",
"TP",
".",
"values",
"(",
")",
")",
"item_sum",
"=",
"sum",
"(",
"item",
".",
"values",
"(",
")",
")",
"return",
"TP_sum",
"/",
"(",
"TP_sum",
"+",
"i... | Calculate PPV_Micro and TPR_Micro.
:param TP: true positive
:type TP:dict
:param item: FN or FP
:type item : dict
:return: PPV_Micro or TPR_Micro as float | [
"Calculate",
"PPV_Micro",
"and",
"TPR_Micro",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_overall_func.py#L648-L663 | train | 231,107 |
sepandhaghighi/pycm | pycm/pycm_overall_func.py | macro_calc | def macro_calc(item):
"""
Calculate PPV_Macro and TPR_Macro.
:param item: PPV or TPR
:type item:dict
:return: PPV_Macro or TPR_Macro as float
"""
try:
item_sum = sum(item.values())
item_len = len(item.values())
return item_sum / item_len
except Exception:
return "None" | python | def macro_calc(item):
"""
Calculate PPV_Macro and TPR_Macro.
:param item: PPV or TPR
:type item:dict
:return: PPV_Macro or TPR_Macro as float
"""
try:
item_sum = sum(item.values())
item_len = len(item.values())
return item_sum / item_len
except Exception:
return "None" | [
"def",
"macro_calc",
"(",
"item",
")",
":",
"try",
":",
"item_sum",
"=",
"sum",
"(",
"item",
".",
"values",
"(",
")",
")",
"item_len",
"=",
"len",
"(",
"item",
".",
"values",
"(",
")",
")",
"return",
"item_sum",
"/",
"item_len",
"except",
"Exception"... | Calculate PPV_Macro and TPR_Macro.
:param item: PPV or TPR
:type item:dict
:return: PPV_Macro or TPR_Macro as float | [
"Calculate",
"PPV_Macro",
"and",
"TPR_Macro",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_overall_func.py#L666-L679 | train | 231,108 |
sepandhaghighi/pycm | pycm/pycm_overall_func.py | PC_PI_calc | def PC_PI_calc(P, TOP, POP):
"""
Calculate percent chance agreement for Scott's Pi.
:param P: condition positive
:type P : dict
:param TOP: test outcome positive
:type TOP : dict
:param POP: population
:type POP:dict
:return: percent chance agreement as float
"""
try:
result = 0
for i in P.keys():
result += ((P[i] + TOP[i]) / (2 * POP[i]))**2
return result
except Exception:
return "None" | python | def PC_PI_calc(P, TOP, POP):
"""
Calculate percent chance agreement for Scott's Pi.
:param P: condition positive
:type P : dict
:param TOP: test outcome positive
:type TOP : dict
:param POP: population
:type POP:dict
:return: percent chance agreement as float
"""
try:
result = 0
for i in P.keys():
result += ((P[i] + TOP[i]) / (2 * POP[i]))**2
return result
except Exception:
return "None" | [
"def",
"PC_PI_calc",
"(",
"P",
",",
"TOP",
",",
"POP",
")",
":",
"try",
":",
"result",
"=",
"0",
"for",
"i",
"in",
"P",
".",
"keys",
"(",
")",
":",
"result",
"+=",
"(",
"(",
"P",
"[",
"i",
"]",
"+",
"TOP",
"[",
"i",
"]",
")",
"/",
"(",
... | Calculate percent chance agreement for Scott's Pi.
:param P: condition positive
:type P : dict
:param TOP: test outcome positive
:type TOP : dict
:param POP: population
:type POP:dict
:return: percent chance agreement as float | [
"Calculate",
"percent",
"chance",
"agreement",
"for",
"Scott",
"s",
"Pi",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_overall_func.py#L682-L700 | train | 231,109 |
sepandhaghighi/pycm | pycm/pycm_overall_func.py | PC_AC1_calc | def PC_AC1_calc(P, TOP, POP):
"""
Calculate percent chance agreement for Gwet's AC1.
:param P: condition positive
:type P : dict
:param TOP: test outcome positive
:type TOP : dict
:param POP: population
:type POP:dict
:return: percent chance agreement as float
"""
try:
result = 0
classes = list(P.keys())
for i in classes:
pi = ((P[i] + TOP[i]) / (2 * POP[i]))
result += pi * (1 - pi)
result = result / (len(classes) - 1)
return result
except Exception:
return "None" | python | def PC_AC1_calc(P, TOP, POP):
"""
Calculate percent chance agreement for Gwet's AC1.
:param P: condition positive
:type P : dict
:param TOP: test outcome positive
:type TOP : dict
:param POP: population
:type POP:dict
:return: percent chance agreement as float
"""
try:
result = 0
classes = list(P.keys())
for i in classes:
pi = ((P[i] + TOP[i]) / (2 * POP[i]))
result += pi * (1 - pi)
result = result / (len(classes) - 1)
return result
except Exception:
return "None" | [
"def",
"PC_AC1_calc",
"(",
"P",
",",
"TOP",
",",
"POP",
")",
":",
"try",
":",
"result",
"=",
"0",
"classes",
"=",
"list",
"(",
"P",
".",
"keys",
"(",
")",
")",
"for",
"i",
"in",
"classes",
":",
"pi",
"=",
"(",
"(",
"P",
"[",
"i",
"]",
"+",
... | Calculate percent chance agreement for Gwet's AC1.
:param P: condition positive
:type P : dict
:param TOP: test outcome positive
:type TOP : dict
:param POP: population
:type POP:dict
:return: percent chance agreement as float | [
"Calculate",
"percent",
"chance",
"agreement",
"for",
"Gwet",
"s",
"AC1",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_overall_func.py#L703-L724 | train | 231,110 |
sepandhaghighi/pycm | pycm/pycm_overall_func.py | overall_jaccard_index_calc | def overall_jaccard_index_calc(jaccard_list):
"""
Calculate overall jaccard index.
:param jaccard_list : list of jaccard index for each class
:type jaccard_list : list
:return: (jaccard_sum , jaccard_mean) as tuple
"""
try:
jaccard_sum = sum(jaccard_list)
jaccard_mean = jaccard_sum / len(jaccard_list)
return (jaccard_sum, jaccard_mean)
except Exception:
return "None" | python | def overall_jaccard_index_calc(jaccard_list):
"""
Calculate overall jaccard index.
:param jaccard_list : list of jaccard index for each class
:type jaccard_list : list
:return: (jaccard_sum , jaccard_mean) as tuple
"""
try:
jaccard_sum = sum(jaccard_list)
jaccard_mean = jaccard_sum / len(jaccard_list)
return (jaccard_sum, jaccard_mean)
except Exception:
return "None" | [
"def",
"overall_jaccard_index_calc",
"(",
"jaccard_list",
")",
":",
"try",
":",
"jaccard_sum",
"=",
"sum",
"(",
"jaccard_list",
")",
"jaccard_mean",
"=",
"jaccard_sum",
"/",
"len",
"(",
"jaccard_list",
")",
"return",
"(",
"jaccard_sum",
",",
"jaccard_mean",
")",... | Calculate overall jaccard index.
:param jaccard_list : list of jaccard index for each class
:type jaccard_list : list
:return: (jaccard_sum , jaccard_mean) as tuple | [
"Calculate",
"overall",
"jaccard",
"index",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_overall_func.py#L741-L754 | train | 231,111 |
sepandhaghighi/pycm | pycm/pycm_overall_func.py | overall_accuracy_calc | def overall_accuracy_calc(TP, POP):
"""
Calculate overall accuracy.
:param TP: true positive
:type TP : dict
:param POP: population
:type POP:int
:return: overall_accuracy as float
"""
try:
overall_accuracy = sum(TP.values()) / POP
return overall_accuracy
except Exception:
return "None" | python | def overall_accuracy_calc(TP, POP):
"""
Calculate overall accuracy.
:param TP: true positive
:type TP : dict
:param POP: population
:type POP:int
:return: overall_accuracy as float
"""
try:
overall_accuracy = sum(TP.values()) / POP
return overall_accuracy
except Exception:
return "None" | [
"def",
"overall_accuracy_calc",
"(",
"TP",
",",
"POP",
")",
":",
"try",
":",
"overall_accuracy",
"=",
"sum",
"(",
"TP",
".",
"values",
"(",
")",
")",
"/",
"POP",
"return",
"overall_accuracy",
"except",
"Exception",
":",
"return",
"\"None\""
] | Calculate overall accuracy.
:param TP: true positive
:type TP : dict
:param POP: population
:type POP:int
:return: overall_accuracy as float | [
"Calculate",
"overall",
"accuracy",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_overall_func.py#L757-L771 | train | 231,112 |
sepandhaghighi/pycm | pycm/pycm_interpret.py | AUC_analysis | def AUC_analysis(AUC):
"""
Analysis AUC with interpretation table.
:param AUC: area under the ROC curve
:type AUC : float
:return: interpretation result as str
"""
try:
if AUC == "None":
return "None"
if AUC < 0.6:
return "Poor"
if AUC >= 0.6 and AUC < 0.7:
return "Fair"
if AUC >= 0.7 and AUC < 0.8:
return "Good"
if AUC >= 0.8 and AUC < 0.9:
return "Very Good"
return "Excellent"
except Exception: # pragma: no cover
return "None" | python | def AUC_analysis(AUC):
"""
Analysis AUC with interpretation table.
:param AUC: area under the ROC curve
:type AUC : float
:return: interpretation result as str
"""
try:
if AUC == "None":
return "None"
if AUC < 0.6:
return "Poor"
if AUC >= 0.6 and AUC < 0.7:
return "Fair"
if AUC >= 0.7 and AUC < 0.8:
return "Good"
if AUC >= 0.8 and AUC < 0.9:
return "Very Good"
return "Excellent"
except Exception: # pragma: no cover
return "None" | [
"def",
"AUC_analysis",
"(",
"AUC",
")",
":",
"try",
":",
"if",
"AUC",
"==",
"\"None\"",
":",
"return",
"\"None\"",
"if",
"AUC",
"<",
"0.6",
":",
"return",
"\"Poor\"",
"if",
"AUC",
">=",
"0.6",
"and",
"AUC",
"<",
"0.7",
":",
"return",
"\"Fair\"",
"if"... | Analysis AUC with interpretation table.
:param AUC: area under the ROC curve
:type AUC : float
:return: interpretation result as str | [
"Analysis",
"AUC",
"with",
"interpretation",
"table",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_interpret.py#L50-L71 | train | 231,113 |
sepandhaghighi/pycm | pycm/pycm_interpret.py | kappa_analysis_cicchetti | def kappa_analysis_cicchetti(kappa):
"""
Analysis kappa number with Cicchetti benchmark.
:param kappa: kappa number
:type kappa : float
:return: strength of agreement as str
"""
try:
if kappa < 0.4:
return "Poor"
if kappa >= 0.4 and kappa < 0.59:
return "Fair"
if kappa >= 0.59 and kappa < 0.74:
return "Good"
if kappa >= 0.74 and kappa <= 1:
return "Excellent"
return "None"
except Exception: # pragma: no cover
return "None" | python | def kappa_analysis_cicchetti(kappa):
"""
Analysis kappa number with Cicchetti benchmark.
:param kappa: kappa number
:type kappa : float
:return: strength of agreement as str
"""
try:
if kappa < 0.4:
return "Poor"
if kappa >= 0.4 and kappa < 0.59:
return "Fair"
if kappa >= 0.59 and kappa < 0.74:
return "Good"
if kappa >= 0.74 and kappa <= 1:
return "Excellent"
return "None"
except Exception: # pragma: no cover
return "None" | [
"def",
"kappa_analysis_cicchetti",
"(",
"kappa",
")",
":",
"try",
":",
"if",
"kappa",
"<",
"0.4",
":",
"return",
"\"Poor\"",
"if",
"kappa",
">=",
"0.4",
"and",
"kappa",
"<",
"0.59",
":",
"return",
"\"Fair\"",
"if",
"kappa",
">=",
"0.59",
"and",
"kappa",
... | Analysis kappa number with Cicchetti benchmark.
:param kappa: kappa number
:type kappa : float
:return: strength of agreement as str | [
"Analysis",
"kappa",
"number",
"with",
"Cicchetti",
"benchmark",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_interpret.py#L74-L93 | train | 231,114 |
sepandhaghighi/pycm | pycm/pycm_interpret.py | kappa_analysis_koch | def kappa_analysis_koch(kappa):
"""
Analysis kappa number with Landis-Koch benchmark.
:param kappa: kappa number
:type kappa : float
:return: strength of agreement as str
"""
try:
if kappa < 0:
return "Poor"
if kappa >= 0 and kappa < 0.2:
return "Slight"
if kappa >= 0.20 and kappa < 0.4:
return "Fair"
if kappa >= 0.40 and kappa < 0.6:
return "Moderate"
if kappa >= 0.60 and kappa < 0.8:
return "Substantial"
if kappa >= 0.80 and kappa <= 1:
return "Almost Perfect"
return "None"
except Exception: # pragma: no cover
return "None" | python | def kappa_analysis_koch(kappa):
"""
Analysis kappa number with Landis-Koch benchmark.
:param kappa: kappa number
:type kappa : float
:return: strength of agreement as str
"""
try:
if kappa < 0:
return "Poor"
if kappa >= 0 and kappa < 0.2:
return "Slight"
if kappa >= 0.20 and kappa < 0.4:
return "Fair"
if kappa >= 0.40 and kappa < 0.6:
return "Moderate"
if kappa >= 0.60 and kappa < 0.8:
return "Substantial"
if kappa >= 0.80 and kappa <= 1:
return "Almost Perfect"
return "None"
except Exception: # pragma: no cover
return "None" | [
"def",
"kappa_analysis_koch",
"(",
"kappa",
")",
":",
"try",
":",
"if",
"kappa",
"<",
"0",
":",
"return",
"\"Poor\"",
"if",
"kappa",
">=",
"0",
"and",
"kappa",
"<",
"0.2",
":",
"return",
"\"Slight\"",
"if",
"kappa",
">=",
"0.20",
"and",
"kappa",
"<",
... | Analysis kappa number with Landis-Koch benchmark.
:param kappa: kappa number
:type kappa : float
:return: strength of agreement as str | [
"Analysis",
"kappa",
"number",
"with",
"Landis",
"-",
"Koch",
"benchmark",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_interpret.py#L96-L119 | train | 231,115 |
sepandhaghighi/pycm | pycm/pycm_interpret.py | kappa_analysis_altman | def kappa_analysis_altman(kappa):
"""
Analysis kappa number with Altman benchmark.
:param kappa: kappa number
:type kappa : float
:return: strength of agreement as str
"""
try:
if kappa < 0.2:
return "Poor"
if kappa >= 0.20 and kappa < 0.4:
return "Fair"
if kappa >= 0.40 and kappa < 0.6:
return "Moderate"
if kappa >= 0.60 and kappa < 0.8:
return "Good"
if kappa >= 0.80 and kappa <= 1:
return "Very Good"
return "None"
except Exception: # pragma: no cover
return "None" | python | def kappa_analysis_altman(kappa):
"""
Analysis kappa number with Altman benchmark.
:param kappa: kappa number
:type kappa : float
:return: strength of agreement as str
"""
try:
if kappa < 0.2:
return "Poor"
if kappa >= 0.20 and kappa < 0.4:
return "Fair"
if kappa >= 0.40 and kappa < 0.6:
return "Moderate"
if kappa >= 0.60 and kappa < 0.8:
return "Good"
if kappa >= 0.80 and kappa <= 1:
return "Very Good"
return "None"
except Exception: # pragma: no cover
return "None" | [
"def",
"kappa_analysis_altman",
"(",
"kappa",
")",
":",
"try",
":",
"if",
"kappa",
"<",
"0.2",
":",
"return",
"\"Poor\"",
"if",
"kappa",
">=",
"0.20",
"and",
"kappa",
"<",
"0.4",
":",
"return",
"\"Fair\"",
"if",
"kappa",
">=",
"0.40",
"and",
"kappa",
"... | Analysis kappa number with Altman benchmark.
:param kappa: kappa number
:type kappa : float
:return: strength of agreement as str | [
"Analysis",
"kappa",
"number",
"with",
"Altman",
"benchmark",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_interpret.py#L141-L162 | train | 231,116 |
sepandhaghighi/pycm | setup.py | get_requires | def get_requires():
"""Read requirements.txt."""
requirements = open("requirements.txt", "r").read()
return list(filter(lambda x: x != "", requirements.split())) | python | def get_requires():
"""Read requirements.txt."""
requirements = open("requirements.txt", "r").read()
return list(filter(lambda x: x != "", requirements.split())) | [
"def",
"get_requires",
"(",
")",
":",
"requirements",
"=",
"open",
"(",
"\"requirements.txt\"",
",",
"\"r\"",
")",
".",
"read",
"(",
")",
"return",
"list",
"(",
"filter",
"(",
"lambda",
"x",
":",
"x",
"!=",
"\"\"",
",",
"requirements",
".",
"split",
"(... | Read requirements.txt. | [
"Read",
"requirements",
".",
"txt",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/setup.py#L9-L12 | train | 231,117 |
sepandhaghighi/pycm | setup.py | read_description | def read_description():
"""Read README.md and CHANGELOG.md."""
try:
with open("README.md") as r:
description = "\n"
description += r.read()
with open("CHANGELOG.md") as c:
description += "\n"
description += c.read()
return description
except Exception:
return '''
PyCM is a multi-class confusion matrix library written in Python that
supports both input data vectors and direct matrix, and a proper tool for
post-classification model evaluation that supports most classes and overall
statistics parameters.
PyCM is the swiss-army knife of confusion matrices, targeted mainly at
data scientists that need a broad array of metrics for predictive models
and an accurate evaluation of large variety of classifiers.''' | python | def read_description():
"""Read README.md and CHANGELOG.md."""
try:
with open("README.md") as r:
description = "\n"
description += r.read()
with open("CHANGELOG.md") as c:
description += "\n"
description += c.read()
return description
except Exception:
return '''
PyCM is a multi-class confusion matrix library written in Python that
supports both input data vectors and direct matrix, and a proper tool for
post-classification model evaluation that supports most classes and overall
statistics parameters.
PyCM is the swiss-army knife of confusion matrices, targeted mainly at
data scientists that need a broad array of metrics for predictive models
and an accurate evaluation of large variety of classifiers.''' | [
"def",
"read_description",
"(",
")",
":",
"try",
":",
"with",
"open",
"(",
"\"README.md\"",
")",
"as",
"r",
":",
"description",
"=",
"\"\\n\"",
"description",
"+=",
"r",
".",
"read",
"(",
")",
"with",
"open",
"(",
"\"CHANGELOG.md\"",
")",
"as",
"c",
":... | Read README.md and CHANGELOG.md. | [
"Read",
"README",
".",
"md",
"and",
"CHANGELOG",
".",
"md",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/setup.py#L15-L33 | train | 231,118 |
sepandhaghighi/pycm | pycm/pycm_obj.py | ConfusionMatrix.print_matrix | def print_matrix(self, one_vs_all=False, class_name=None):
"""
Print confusion matrix.
:param one_vs_all : One-Vs-All mode flag
:type one_vs_all : bool
:param class_name : target class name for One-Vs-All mode
:type class_name : any valid type
:return: None
"""
classes = self.classes
table = self.table
if one_vs_all:
[classes, table] = one_vs_all_func(
classes, table, self.TP, self.TN, self.FP, self.FN, class_name)
print(table_print(classes, table)) | python | def print_matrix(self, one_vs_all=False, class_name=None):
"""
Print confusion matrix.
:param one_vs_all : One-Vs-All mode flag
:type one_vs_all : bool
:param class_name : target class name for One-Vs-All mode
:type class_name : any valid type
:return: None
"""
classes = self.classes
table = self.table
if one_vs_all:
[classes, table] = one_vs_all_func(
classes, table, self.TP, self.TN, self.FP, self.FN, class_name)
print(table_print(classes, table)) | [
"def",
"print_matrix",
"(",
"self",
",",
"one_vs_all",
"=",
"False",
",",
"class_name",
"=",
"None",
")",
":",
"classes",
"=",
"self",
".",
"classes",
"table",
"=",
"self",
".",
"table",
"if",
"one_vs_all",
":",
"[",
"classes",
",",
"table",
"]",
"=",
... | Print confusion matrix.
:param one_vs_all : One-Vs-All mode flag
:type one_vs_all : bool
:param class_name : target class name for One-Vs-All mode
:type class_name : any valid type
:return: None | [
"Print",
"confusion",
"matrix",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_obj.py#L94-L109 | train | 231,119 |
sepandhaghighi/pycm | pycm/pycm_obj.py | ConfusionMatrix.stat | def stat(self, overall_param=None, class_param=None, class_name=None):
"""
Print statistical measures table.
:param overall_param : overall parameters list for print, Example : ["Kappa","Scott PI]
:type overall_param : list
:param class_param : class parameters list for print, Example : ["TPR","TNR","AUC"]
:type class_param : list
:param class_name : class name (sub set of classes), Example :[1,2,3]
:type class_name : list
:return: None
"""
classes = class_filter(self.classes, class_name)
print(
stat_print(
classes,
self.class_stat,
self.overall_stat,
self.digit, overall_param, class_param)) | python | def stat(self, overall_param=None, class_param=None, class_name=None):
"""
Print statistical measures table.
:param overall_param : overall parameters list for print, Example : ["Kappa","Scott PI]
:type overall_param : list
:param class_param : class parameters list for print, Example : ["TPR","TNR","AUC"]
:type class_param : list
:param class_name : class name (sub set of classes), Example :[1,2,3]
:type class_name : list
:return: None
"""
classes = class_filter(self.classes, class_name)
print(
stat_print(
classes,
self.class_stat,
self.overall_stat,
self.digit, overall_param, class_param)) | [
"def",
"stat",
"(",
"self",
",",
"overall_param",
"=",
"None",
",",
"class_param",
"=",
"None",
",",
"class_name",
"=",
"None",
")",
":",
"classes",
"=",
"class_filter",
"(",
"self",
".",
"classes",
",",
"class_name",
")",
"print",
"(",
"stat_print",
"("... | Print statistical measures table.
:param overall_param : overall parameters list for print, Example : ["Kappa","Scott PI]
:type overall_param : list
:param class_param : class parameters list for print, Example : ["TPR","TNR","AUC"]
:type class_param : list
:param class_name : class name (sub set of classes), Example :[1,2,3]
:type class_name : list
:return: None | [
"Print",
"statistical",
"measures",
"table",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_obj.py#L129-L147 | train | 231,120 |
sepandhaghighi/pycm | pycm/pycm_obj.py | ConfusionMatrix.save_html | def save_html(
self,
name,
address=True,
overall_param=None,
class_param=None,
class_name=None, color=(0, 0, 0), normalize=False):
"""
Save ConfusionMatrix in HTML file.
:param name: filename
:type name : str
:param address: flag for address return
:type address : bool
:param overall_param : overall parameters list for save, Example : ["Kappa","Scott PI]
:type overall_param : list
:param class_param : class parameters list for save, Example : ["TPR","TNR","AUC"]
:type class_param : list
:param class_name : class name (sub set of classes), Example :[1,2,3]
:type class_name : list
:param color : matrix color (R,G,B)
:type color : tuple
:param normalize : save normalize matrix flag
:type normalize : bool
:return: saving Status as dict {"Status":bool , "Message":str}
"""
try:
message = None
table = self.table
if normalize:
table = self.normalized_table
html_file = open(name + ".html", "w")
html_file.write(html_init(name))
html_file.write(html_dataset_type(self.binary, self.imbalance))
html_file.write(html_table(self.classes, table, color, normalize))
html_file.write(
html_overall_stat(
self.overall_stat,
self.digit,
overall_param,
self.recommended_list))
class_stat_classes = class_filter(self.classes, class_name)
html_file.write(
html_class_stat(
class_stat_classes,
self.class_stat,
self.digit,
class_param,
self.recommended_list))
html_file.write(html_end(VERSION))
html_file.close()
if address:
message = os.path.join(os.getcwd(), name + ".html")
return {"Status": True, "Message": message}
except Exception as e:
return {"Status": False, "Message": str(e)} | python | def save_html(
self,
name,
address=True,
overall_param=None,
class_param=None,
class_name=None, color=(0, 0, 0), normalize=False):
"""
Save ConfusionMatrix in HTML file.
:param name: filename
:type name : str
:param address: flag for address return
:type address : bool
:param overall_param : overall parameters list for save, Example : ["Kappa","Scott PI]
:type overall_param : list
:param class_param : class parameters list for save, Example : ["TPR","TNR","AUC"]
:type class_param : list
:param class_name : class name (sub set of classes), Example :[1,2,3]
:type class_name : list
:param color : matrix color (R,G,B)
:type color : tuple
:param normalize : save normalize matrix flag
:type normalize : bool
:return: saving Status as dict {"Status":bool , "Message":str}
"""
try:
message = None
table = self.table
if normalize:
table = self.normalized_table
html_file = open(name + ".html", "w")
html_file.write(html_init(name))
html_file.write(html_dataset_type(self.binary, self.imbalance))
html_file.write(html_table(self.classes, table, color, normalize))
html_file.write(
html_overall_stat(
self.overall_stat,
self.digit,
overall_param,
self.recommended_list))
class_stat_classes = class_filter(self.classes, class_name)
html_file.write(
html_class_stat(
class_stat_classes,
self.class_stat,
self.digit,
class_param,
self.recommended_list))
html_file.write(html_end(VERSION))
html_file.close()
if address:
message = os.path.join(os.getcwd(), name + ".html")
return {"Status": True, "Message": message}
except Exception as e:
return {"Status": False, "Message": str(e)} | [
"def",
"save_html",
"(",
"self",
",",
"name",
",",
"address",
"=",
"True",
",",
"overall_param",
"=",
"None",
",",
"class_param",
"=",
"None",
",",
"class_name",
"=",
"None",
",",
"color",
"=",
"(",
"0",
",",
"0",
",",
"0",
")",
",",
"normalize",
"... | Save ConfusionMatrix in HTML file.
:param name: filename
:type name : str
:param address: flag for address return
:type address : bool
:param overall_param : overall parameters list for save, Example : ["Kappa","Scott PI]
:type overall_param : list
:param class_param : class parameters list for save, Example : ["TPR","TNR","AUC"]
:type class_param : list
:param class_name : class name (sub set of classes), Example :[1,2,3]
:type class_name : list
:param color : matrix color (R,G,B)
:type color : tuple
:param normalize : save normalize matrix flag
:type normalize : bool
:return: saving Status as dict {"Status":bool , "Message":str} | [
"Save",
"ConfusionMatrix",
"in",
"HTML",
"file",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_obj.py#L212-L267 | train | 231,121 |
sepandhaghighi/pycm | pycm/pycm_obj.py | ConfusionMatrix.save_csv | def save_csv(
self,
name,
address=True,
class_param=None,
class_name=None,
matrix_save=True,
normalize=False):
"""
Save ConfusionMatrix in CSV file.
:param name: filename
:type name : str
:param address: flag for address return
:type address : bool
:param class_param : class parameters list for save, Example : ["TPR","TNR","AUC"]
:type class_param : list
:param class_name : class name (sub set of classes), Example :[1,2,3]
:type class_name : list
:param matrix_save : save matrix flag
:type matrix_save : bool
:param normalize : save normalize matrix flag
:type normalize : bool
:return: saving Status as dict {"Status":bool , "Message":str}
"""
try:
message = None
classes = class_filter(self.classes, class_name)
csv_file = open(name + ".csv", "w")
csv_data = csv_print(
classes,
self.class_stat,
self.digit,
class_param)
csv_file.write(csv_data)
if matrix_save:
matrix = self.table
if normalize:
matrix = self.normalized_table
csv_matrix_file = open(name + "_matrix" + ".csv", "w")
csv_matrix_data = csv_matrix_print(self.classes, matrix)
csv_matrix_file.write(csv_matrix_data)
if address:
message = os.path.join(os.getcwd(), name + ".csv")
return {"Status": True, "Message": message}
except Exception as e:
return {"Status": False, "Message": str(e)} | python | def save_csv(
self,
name,
address=True,
class_param=None,
class_name=None,
matrix_save=True,
normalize=False):
"""
Save ConfusionMatrix in CSV file.
:param name: filename
:type name : str
:param address: flag for address return
:type address : bool
:param class_param : class parameters list for save, Example : ["TPR","TNR","AUC"]
:type class_param : list
:param class_name : class name (sub set of classes), Example :[1,2,3]
:type class_name : list
:param matrix_save : save matrix flag
:type matrix_save : bool
:param normalize : save normalize matrix flag
:type normalize : bool
:return: saving Status as dict {"Status":bool , "Message":str}
"""
try:
message = None
classes = class_filter(self.classes, class_name)
csv_file = open(name + ".csv", "w")
csv_data = csv_print(
classes,
self.class_stat,
self.digit,
class_param)
csv_file.write(csv_data)
if matrix_save:
matrix = self.table
if normalize:
matrix = self.normalized_table
csv_matrix_file = open(name + "_matrix" + ".csv", "w")
csv_matrix_data = csv_matrix_print(self.classes, matrix)
csv_matrix_file.write(csv_matrix_data)
if address:
message = os.path.join(os.getcwd(), name + ".csv")
return {"Status": True, "Message": message}
except Exception as e:
return {"Status": False, "Message": str(e)} | [
"def",
"save_csv",
"(",
"self",
",",
"name",
",",
"address",
"=",
"True",
",",
"class_param",
"=",
"None",
",",
"class_name",
"=",
"None",
",",
"matrix_save",
"=",
"True",
",",
"normalize",
"=",
"False",
")",
":",
"try",
":",
"message",
"=",
"None",
... | Save ConfusionMatrix in CSV file.
:param name: filename
:type name : str
:param address: flag for address return
:type address : bool
:param class_param : class parameters list for save, Example : ["TPR","TNR","AUC"]
:type class_param : list
:param class_name : class name (sub set of classes), Example :[1,2,3]
:type class_name : list
:param matrix_save : save matrix flag
:type matrix_save : bool
:param normalize : save normalize matrix flag
:type normalize : bool
:return: saving Status as dict {"Status":bool , "Message":str} | [
"Save",
"ConfusionMatrix",
"in",
"CSV",
"file",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_obj.py#L269-L315 | train | 231,122 |
sepandhaghighi/pycm | pycm/pycm_obj.py | ConfusionMatrix.save_obj | def save_obj(self, name, address=True):
"""
Save ConfusionMatrix in .obj file.
:param name: filename
:type name : str
:param address: flag for address return
:type address : bool
:return: saving Status as dict {"Status":bool , "Message":str}
"""
try:
message = None
obj_file = open(name + ".obj", "w")
actual_vector_temp = self.actual_vector
predict_vector_temp = self.predict_vector
matrix_temp = {k: self.table[k].copy() for k in self.classes}
matrix_items = []
for i in self.classes:
matrix_items.append((i, list(matrix_temp[i].items())))
if isinstance(actual_vector_temp, numpy.ndarray):
actual_vector_temp = actual_vector_temp.tolist()
if isinstance(predict_vector_temp, numpy.ndarray):
predict_vector_temp = predict_vector_temp.tolist()
json.dump({"Actual-Vector": actual_vector_temp,
"Predict-Vector": predict_vector_temp,
"Matrix": matrix_items,
"Digit": self.digit,
"Sample-Weight": self.weights,
"Transpose": self.transpose}, obj_file)
if address:
message = os.path.join(os.getcwd(), name + ".obj")
return {"Status": True, "Message": message}
except Exception as e:
return {"Status": False, "Message": str(e)} | python | def save_obj(self, name, address=True):
"""
Save ConfusionMatrix in .obj file.
:param name: filename
:type name : str
:param address: flag for address return
:type address : bool
:return: saving Status as dict {"Status":bool , "Message":str}
"""
try:
message = None
obj_file = open(name + ".obj", "w")
actual_vector_temp = self.actual_vector
predict_vector_temp = self.predict_vector
matrix_temp = {k: self.table[k].copy() for k in self.classes}
matrix_items = []
for i in self.classes:
matrix_items.append((i, list(matrix_temp[i].items())))
if isinstance(actual_vector_temp, numpy.ndarray):
actual_vector_temp = actual_vector_temp.tolist()
if isinstance(predict_vector_temp, numpy.ndarray):
predict_vector_temp = predict_vector_temp.tolist()
json.dump({"Actual-Vector": actual_vector_temp,
"Predict-Vector": predict_vector_temp,
"Matrix": matrix_items,
"Digit": self.digit,
"Sample-Weight": self.weights,
"Transpose": self.transpose}, obj_file)
if address:
message = os.path.join(os.getcwd(), name + ".obj")
return {"Status": True, "Message": message}
except Exception as e:
return {"Status": False, "Message": str(e)} | [
"def",
"save_obj",
"(",
"self",
",",
"name",
",",
"address",
"=",
"True",
")",
":",
"try",
":",
"message",
"=",
"None",
"obj_file",
"=",
"open",
"(",
"name",
"+",
"\".obj\"",
",",
"\"w\"",
")",
"actual_vector_temp",
"=",
"self",
".",
"actual_vector",
"... | Save ConfusionMatrix in .obj file.
:param name: filename
:type name : str
:param address: flag for address return
:type address : bool
:return: saving Status as dict {"Status":bool , "Message":str} | [
"Save",
"ConfusionMatrix",
"in",
".",
"obj",
"file",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_obj.py#L317-L350 | train | 231,123 |
sepandhaghighi/pycm | pycm/pycm_obj.py | ConfusionMatrix.F_beta | def F_beta(self, beta):
"""
Calculate FBeta score.
:param beta: beta parameter
:type beta : float
:return: FBeta score for classes as dict
"""
try:
F_dict = {}
for i in self.TP.keys():
F_dict[i] = F_calc(
TP=self.TP[i],
FP=self.FP[i],
FN=self.FN[i],
beta=beta)
return F_dict
except Exception:
return {} | python | def F_beta(self, beta):
"""
Calculate FBeta score.
:param beta: beta parameter
:type beta : float
:return: FBeta score for classes as dict
"""
try:
F_dict = {}
for i in self.TP.keys():
F_dict[i] = F_calc(
TP=self.TP[i],
FP=self.FP[i],
FN=self.FN[i],
beta=beta)
return F_dict
except Exception:
return {} | [
"def",
"F_beta",
"(",
"self",
",",
"beta",
")",
":",
"try",
":",
"F_dict",
"=",
"{",
"}",
"for",
"i",
"in",
"self",
".",
"TP",
".",
"keys",
"(",
")",
":",
"F_dict",
"[",
"i",
"]",
"=",
"F_calc",
"(",
"TP",
"=",
"self",
".",
"TP",
"[",
"i",
... | Calculate FBeta score.
:param beta: beta parameter
:type beta : float
:return: FBeta score for classes as dict | [
"Calculate",
"FBeta",
"score",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_obj.py#L352-L370 | train | 231,124 |
sepandhaghighi/pycm | pycm/pycm_obj.py | ConfusionMatrix.IBA_alpha | def IBA_alpha(self, alpha):
"""
Calculate IBA_alpha score.
:param alpha: alpha parameter
:type alpha: float
:return: IBA_alpha score for classes as dict
"""
try:
IBA_dict = {}
for i in self.classes:
IBA_dict[i] = IBA_calc(self.TPR[i], self.TNR[i], alpha=alpha)
return IBA_dict
except Exception:
return {} | python | def IBA_alpha(self, alpha):
"""
Calculate IBA_alpha score.
:param alpha: alpha parameter
:type alpha: float
:return: IBA_alpha score for classes as dict
"""
try:
IBA_dict = {}
for i in self.classes:
IBA_dict[i] = IBA_calc(self.TPR[i], self.TNR[i], alpha=alpha)
return IBA_dict
except Exception:
return {} | [
"def",
"IBA_alpha",
"(",
"self",
",",
"alpha",
")",
":",
"try",
":",
"IBA_dict",
"=",
"{",
"}",
"for",
"i",
"in",
"self",
".",
"classes",
":",
"IBA_dict",
"[",
"i",
"]",
"=",
"IBA_calc",
"(",
"self",
".",
"TPR",
"[",
"i",
"]",
",",
"self",
".",... | Calculate IBA_alpha score.
:param alpha: alpha parameter
:type alpha: float
:return: IBA_alpha score for classes as dict | [
"Calculate",
"IBA_alpha",
"score",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_obj.py#L372-L386 | train | 231,125 |
sepandhaghighi/pycm | pycm/pycm_obj.py | ConfusionMatrix.relabel | def relabel(self, mapping):
"""
Rename ConfusionMatrix classes.
:param mapping: mapping dictionary
:type mapping : dict
:return: None
"""
if not isinstance(mapping, dict):
raise pycmMatrixError(MAPPING_FORMAT_ERROR)
if self.classes != list(mapping.keys()):
raise pycmMatrixError(MAPPING_CLASS_NAME_ERROR)
for row in self.classes:
temp_dict = {}
temp_dict_normalized = {}
for col in self.classes:
temp_dict[mapping[col]] = self.table[row][col]
temp_dict_normalized[mapping[col]
] = self.normalized_table[row][col]
del self.table[row]
self.table[mapping[row]] = temp_dict
del self.normalized_table[row]
self.normalized_table[mapping[row]] = temp_dict_normalized
self.matrix = self.table
self.normalized_matrix = self.normalized_table
for param in self.class_stat.keys():
temp_dict = {}
for classname in self.classes:
temp_dict[mapping[classname]
] = self.class_stat[param][classname]
self.class_stat[param] = temp_dict
self.classes = list(mapping.values())
self.TP = self.class_stat["TP"]
self.TN = self.class_stat["TN"]
self.FP = self.class_stat["FP"]
self.FN = self.class_stat["FN"]
__class_stat_init__(self) | python | def relabel(self, mapping):
"""
Rename ConfusionMatrix classes.
:param mapping: mapping dictionary
:type mapping : dict
:return: None
"""
if not isinstance(mapping, dict):
raise pycmMatrixError(MAPPING_FORMAT_ERROR)
if self.classes != list(mapping.keys()):
raise pycmMatrixError(MAPPING_CLASS_NAME_ERROR)
for row in self.classes:
temp_dict = {}
temp_dict_normalized = {}
for col in self.classes:
temp_dict[mapping[col]] = self.table[row][col]
temp_dict_normalized[mapping[col]
] = self.normalized_table[row][col]
del self.table[row]
self.table[mapping[row]] = temp_dict
del self.normalized_table[row]
self.normalized_table[mapping[row]] = temp_dict_normalized
self.matrix = self.table
self.normalized_matrix = self.normalized_table
for param in self.class_stat.keys():
temp_dict = {}
for classname in self.classes:
temp_dict[mapping[classname]
] = self.class_stat[param][classname]
self.class_stat[param] = temp_dict
self.classes = list(mapping.values())
self.TP = self.class_stat["TP"]
self.TN = self.class_stat["TN"]
self.FP = self.class_stat["FP"]
self.FN = self.class_stat["FN"]
__class_stat_init__(self) | [
"def",
"relabel",
"(",
"self",
",",
"mapping",
")",
":",
"if",
"not",
"isinstance",
"(",
"mapping",
",",
"dict",
")",
":",
"raise",
"pycmMatrixError",
"(",
"MAPPING_FORMAT_ERROR",
")",
"if",
"self",
".",
"classes",
"!=",
"list",
"(",
"mapping",
".",
"key... | Rename ConfusionMatrix classes.
:param mapping: mapping dictionary
:type mapping : dict
:return: None | [
"Rename",
"ConfusionMatrix",
"classes",
"."
] | cb03258afd6a821d10acba73c965aaac174bedcd | https://github.com/sepandhaghighi/pycm/blob/cb03258afd6a821d10acba73c965aaac174bedcd/pycm/pycm_obj.py#L426-L462 | train | 231,126 |
manns/pyspread | pyspread/src/gui/_toolbars.py | ToolbarBase.add_tools | def add_tools(self):
"""Adds tools from self.toolbardata to self"""
for data in self.toolbardata:
# tool type is in data[0]
if data[0] == "T":
# Simple tool
_, msg_type, label, tool_tip = data
icon = icons[label]
self.label2id[label] = tool_id = wx.NewId()
self.AddSimpleTool(tool_id, label, icon,
short_help_string=tool_tip)
self.ids_msgs[tool_id] = msg_type
self.parent.Bind(wx.EVT_TOOL, self.OnTool, id=tool_id)
elif data[0] == "S":
# Separator
self.AddSeparator()
elif data[0] == "C":
# Control
_, control, tool_tip = data
self.AddControl(control, label=tool_tip)
elif data[0] == "O":
# Check tool / option button
_, label, tool_tip = data
icon = icons[label]
self.label2id[label] = tool_id = wx.NewId()
self.AddCheckTool(tool_id, label, icon, icon, tool_tip)
else:
raise ValueError("Unknown tooltype " + str(data[0]))
self.SetCustomOverflowItems([], [])
self.Realize()
# Adjust Toolbar size
self.SetSize(self.DoGetBestSize()) | python | def add_tools(self):
"""Adds tools from self.toolbardata to self"""
for data in self.toolbardata:
# tool type is in data[0]
if data[0] == "T":
# Simple tool
_, msg_type, label, tool_tip = data
icon = icons[label]
self.label2id[label] = tool_id = wx.NewId()
self.AddSimpleTool(tool_id, label, icon,
short_help_string=tool_tip)
self.ids_msgs[tool_id] = msg_type
self.parent.Bind(wx.EVT_TOOL, self.OnTool, id=tool_id)
elif data[0] == "S":
# Separator
self.AddSeparator()
elif data[0] == "C":
# Control
_, control, tool_tip = data
self.AddControl(control, label=tool_tip)
elif data[0] == "O":
# Check tool / option button
_, label, tool_tip = data
icon = icons[label]
self.label2id[label] = tool_id = wx.NewId()
self.AddCheckTool(tool_id, label, icon, icon, tool_tip)
else:
raise ValueError("Unknown tooltype " + str(data[0]))
self.SetCustomOverflowItems([], [])
self.Realize()
# Adjust Toolbar size
self.SetSize(self.DoGetBestSize()) | [
"def",
"add_tools",
"(",
"self",
")",
":",
"for",
"data",
"in",
"self",
".",
"toolbardata",
":",
"# tool type is in data[0]",
"if",
"data",
"[",
"0",
"]",
"==",
"\"T\"",
":",
"# Simple tool",
"_",
",",
"msg_type",
",",
"label",
",",
"tool_tip",
"=",
"dat... | Adds tools from self.toolbardata to self | [
"Adds",
"tools",
"from",
"self",
".",
"toolbardata",
"to",
"self"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L96-L146 | train | 231,127 |
manns/pyspread | pyspread/src/gui/_toolbars.py | ToolbarBase.OnTool | def OnTool(self, event):
"""Toolbar event handler"""
msgtype = self.ids_msgs[event.GetId()]
post_command_event(self, msgtype) | python | def OnTool(self, event):
"""Toolbar event handler"""
msgtype = self.ids_msgs[event.GetId()]
post_command_event(self, msgtype) | [
"def",
"OnTool",
"(",
"self",
",",
"event",
")",
":",
"msgtype",
"=",
"self",
".",
"ids_msgs",
"[",
"event",
".",
"GetId",
"(",
")",
"]",
"post_command_event",
"(",
"self",
",",
"msgtype",
")"
] | Toolbar event handler | [
"Toolbar",
"event",
"handler"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L148-L152 | train | 231,128 |
manns/pyspread | pyspread/src/gui/_toolbars.py | MainToolbar.OnToggleTool | def OnToggleTool(self, event):
"""Tool event handler"""
config["check_spelling"] = str(event.IsChecked())
toggle_id = self.parent.menubar.FindMenuItem(_("View"),
_("Check spelling"))
if toggle_id != -1:
# Check may fail if translation is incomplete
toggle_item = self.parent.menubar.FindItemById(toggle_id)
toggle_item.Check(event.IsChecked())
self.parent.grid.grid_renderer.cell_cache.clear()
self.parent.grid.ForceRefresh()
event.Skip() | python | def OnToggleTool(self, event):
"""Tool event handler"""
config["check_spelling"] = str(event.IsChecked())
toggle_id = self.parent.menubar.FindMenuItem(_("View"),
_("Check spelling"))
if toggle_id != -1:
# Check may fail if translation is incomplete
toggle_item = self.parent.menubar.FindItemById(toggle_id)
toggle_item.Check(event.IsChecked())
self.parent.grid.grid_renderer.cell_cache.clear()
self.parent.grid.ForceRefresh()
event.Skip() | [
"def",
"OnToggleTool",
"(",
"self",
",",
"event",
")",
":",
"config",
"[",
"\"check_spelling\"",
"]",
"=",
"str",
"(",
"event",
".",
"IsChecked",
"(",
")",
")",
"toggle_id",
"=",
"self",
".",
"parent",
".",
"menubar",
".",
"FindMenuItem",
"(",
"_",
"("... | Tool event handler | [
"Tool",
"event",
"handler"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L209-L223 | train | 231,129 |
manns/pyspread | pyspread/src/gui/_toolbars.py | WidgetToolbar._get_button_label | def _get_button_label(self):
"""Gets Button label from user and returns string"""
dlg = wx.TextEntryDialog(self, _('Button label:'))
if dlg.ShowModal() == wx.ID_OK:
label = dlg.GetValue()
else:
label = ""
dlg.Destroy()
return label | python | def _get_button_label(self):
"""Gets Button label from user and returns string"""
dlg = wx.TextEntryDialog(self, _('Button label:'))
if dlg.ShowModal() == wx.ID_OK:
label = dlg.GetValue()
else:
label = ""
dlg.Destroy()
return label | [
"def",
"_get_button_label",
"(",
"self",
")",
":",
"dlg",
"=",
"wx",
".",
"TextEntryDialog",
"(",
"self",
",",
"_",
"(",
"'Button label:'",
")",
")",
"if",
"dlg",
".",
"ShowModal",
"(",
")",
"==",
"wx",
".",
"ID_OK",
":",
"label",
"=",
"dlg",
".",
... | Gets Button label from user and returns string | [
"Gets",
"Button",
"label",
"from",
"user",
"and",
"returns",
"string"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L303-L315 | train | 231,130 |
manns/pyspread | pyspread/src/gui/_toolbars.py | WidgetToolbar.OnButtonCell | def OnButtonCell(self, event):
"""Event handler for cell button toggle button"""
if self.button_cell_button_id == event.GetId():
if event.IsChecked():
label = self._get_button_label()
post_command_event(self, self.ButtonCellMsg, text=label)
else:
post_command_event(self, self.ButtonCellMsg, text=False)
event.Skip() | python | def OnButtonCell(self, event):
"""Event handler for cell button toggle button"""
if self.button_cell_button_id == event.GetId():
if event.IsChecked():
label = self._get_button_label()
post_command_event(self, self.ButtonCellMsg, text=label)
else:
post_command_event(self, self.ButtonCellMsg, text=False)
event.Skip() | [
"def",
"OnButtonCell",
"(",
"self",
",",
"event",
")",
":",
"if",
"self",
".",
"button_cell_button_id",
"==",
"event",
".",
"GetId",
"(",
")",
":",
"if",
"event",
".",
"IsChecked",
"(",
")",
":",
"label",
"=",
"self",
".",
"_get_button_label",
"(",
")"... | Event handler for cell button toggle button | [
"Event",
"handler",
"for",
"cell",
"button",
"toggle",
"button"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L317-L327 | train | 231,131 |
manns/pyspread | pyspread/src/gui/_toolbars.py | WidgetToolbar.OnVideoCell | def OnVideoCell(self, event):
"""Event handler for video cell toggle button"""
if self.video_cell_button_id == event.GetId():
if event.IsChecked():
wildcard = _("Media files") + " (*.*)|*.*"
videofile, __ = self.get_filepath_findex_from_user(
wildcard, "Choose video or audio file", wx.OPEN)
post_command_event(self, self.VideoCellMsg,
videofile=videofile)
else:
post_command_event(self, self.VideoCellMsg, videofile=False)
event.Skip() | python | def OnVideoCell(self, event):
"""Event handler for video cell toggle button"""
if self.video_cell_button_id == event.GetId():
if event.IsChecked():
wildcard = _("Media files") + " (*.*)|*.*"
videofile, __ = self.get_filepath_findex_from_user(
wildcard, "Choose video or audio file", wx.OPEN)
post_command_event(self, self.VideoCellMsg,
videofile=videofile)
else:
post_command_event(self, self.VideoCellMsg, videofile=False)
event.Skip() | [
"def",
"OnVideoCell",
"(",
"self",
",",
"event",
")",
":",
"if",
"self",
".",
"video_cell_button_id",
"==",
"event",
".",
"GetId",
"(",
")",
":",
"if",
"event",
".",
"IsChecked",
"(",
")",
":",
"wildcard",
"=",
"_",
"(",
"\"Media files\"",
")",
"+",
... | Event handler for video cell toggle button | [
"Event",
"handler",
"for",
"video",
"cell",
"toggle",
"button"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L329-L342 | train | 231,132 |
manns/pyspread | pyspread/src/gui/_toolbars.py | FindToolbar.make_menu | def make_menu(self):
"""Creates the search menu"""
menu = wx.Menu()
item = menu.Append(-1, "Recent Searches")
item.Enable(False)
for __id, txt in enumerate(self.search_history):
menu.Append(__id, txt)
return menu | python | def make_menu(self):
"""Creates the search menu"""
menu = wx.Menu()
item = menu.Append(-1, "Recent Searches")
item.Enable(False)
for __id, txt in enumerate(self.search_history):
menu.Append(__id, txt)
return menu | [
"def",
"make_menu",
"(",
"self",
")",
":",
"menu",
"=",
"wx",
".",
"Menu",
"(",
")",
"item",
"=",
"menu",
".",
"Append",
"(",
"-",
"1",
",",
"\"Recent Searches\"",
")",
"item",
".",
"Enable",
"(",
"False",
")",
"for",
"__id",
",",
"txt",
"in",
"e... | Creates the search menu | [
"Creates",
"the",
"search",
"menu"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L427-L436 | train | 231,133 |
manns/pyspread | pyspread/src/gui/_toolbars.py | FindToolbar.OnMenu | def OnMenu(self, event):
"""Search history has been selected"""
__id = event.GetId()
try:
menuitem = event.GetEventObject().FindItemById(__id)
selected_text = menuitem.GetItemLabel()
self.search.SetValue(selected_text)
except AttributeError:
# Not called by menu
event.Skip() | python | def OnMenu(self, event):
"""Search history has been selected"""
__id = event.GetId()
try:
menuitem = event.GetEventObject().FindItemById(__id)
selected_text = menuitem.GetItemLabel()
self.search.SetValue(selected_text)
except AttributeError:
# Not called by menu
event.Skip() | [
"def",
"OnMenu",
"(",
"self",
",",
"event",
")",
":",
"__id",
"=",
"event",
".",
"GetId",
"(",
")",
"try",
":",
"menuitem",
"=",
"event",
".",
"GetEventObject",
"(",
")",
".",
"FindItemById",
"(",
"__id",
")",
"selected_text",
"=",
"menuitem",
".",
"... | Search history has been selected | [
"Search",
"history",
"has",
"been",
"selected"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L438-L448 | train | 231,134 |
manns/pyspread | pyspread/src/gui/_toolbars.py | FindToolbar.OnSearch | def OnSearch(self, event):
"""Event handler for starting the search"""
search_string = self.search.GetValue()
if search_string not in self.search_history:
self.search_history.append(search_string)
if len(self.search_history) > 10:
self.search_history.pop(0)
self.menu = self.make_menu()
self.search.SetMenu(self.menu)
search_flags = self.search_options + ["FIND_NEXT"]
post_command_event(self, self.FindMsg, text=search_string,
flags=search_flags)
self.search.SetFocus() | python | def OnSearch(self, event):
"""Event handler for starting the search"""
search_string = self.search.GetValue()
if search_string not in self.search_history:
self.search_history.append(search_string)
if len(self.search_history) > 10:
self.search_history.pop(0)
self.menu = self.make_menu()
self.search.SetMenu(self.menu)
search_flags = self.search_options + ["FIND_NEXT"]
post_command_event(self, self.FindMsg, text=search_string,
flags=search_flags)
self.search.SetFocus() | [
"def",
"OnSearch",
"(",
"self",
",",
"event",
")",
":",
"search_string",
"=",
"self",
".",
"search",
".",
"GetValue",
"(",
")",
"if",
"search_string",
"not",
"in",
"self",
".",
"search_history",
":",
"self",
".",
"search_history",
".",
"append",
"(",
"se... | Event handler for starting the search | [
"Event",
"handler",
"for",
"starting",
"the",
"search"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L450-L468 | train | 231,135 |
manns/pyspread | pyspread/src/gui/_toolbars.py | FindToolbar.OnSearchDirectionButton | def OnSearchDirectionButton(self, event):
"""Event handler for search direction toggle button"""
if "DOWN" in self.search_options:
flag_index = self.search_options.index("DOWN")
self.search_options[flag_index] = "UP"
elif "UP" in self.search_options:
flag_index = self.search_options.index("UP")
self.search_options[flag_index] = "DOWN"
else:
raise AttributeError(_("Neither UP nor DOWN in search_flags"))
event.Skip() | python | def OnSearchDirectionButton(self, event):
"""Event handler for search direction toggle button"""
if "DOWN" in self.search_options:
flag_index = self.search_options.index("DOWN")
self.search_options[flag_index] = "UP"
elif "UP" in self.search_options:
flag_index = self.search_options.index("UP")
self.search_options[flag_index] = "DOWN"
else:
raise AttributeError(_("Neither UP nor DOWN in search_flags"))
event.Skip() | [
"def",
"OnSearchDirectionButton",
"(",
"self",
",",
"event",
")",
":",
"if",
"\"DOWN\"",
"in",
"self",
".",
"search_options",
":",
"flag_index",
"=",
"self",
".",
"search_options",
".",
"index",
"(",
"\"DOWN\"",
")",
"self",
".",
"search_options",
"[",
"flag... | Event handler for search direction toggle button | [
"Event",
"handler",
"for",
"search",
"direction",
"toggle",
"button"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L470-L482 | train | 231,136 |
manns/pyspread | pyspread/src/gui/_toolbars.py | FindToolbar.OnSearchFlag | def OnSearchFlag(self, event):
"""Event handler for search flag toggle buttons"""
for label in self.search_options_buttons:
button_id = self.label2id[label]
if button_id == event.GetId():
if event.IsChecked():
self.search_options.append(label)
else:
flag_index = self.search_options.index(label)
self.search_options.pop(flag_index)
event.Skip() | python | def OnSearchFlag(self, event):
"""Event handler for search flag toggle buttons"""
for label in self.search_options_buttons:
button_id = self.label2id[label]
if button_id == event.GetId():
if event.IsChecked():
self.search_options.append(label)
else:
flag_index = self.search_options.index(label)
self.search_options.pop(flag_index)
event.Skip() | [
"def",
"OnSearchFlag",
"(",
"self",
",",
"event",
")",
":",
"for",
"label",
"in",
"self",
".",
"search_options_buttons",
":",
"button_id",
"=",
"self",
".",
"label2id",
"[",
"label",
"]",
"if",
"button_id",
"==",
"event",
".",
"GetId",
"(",
")",
":",
"... | Event handler for search flag toggle buttons | [
"Event",
"handler",
"for",
"search",
"flag",
"toggle",
"buttons"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L484-L496 | train | 231,137 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar._create_font_choice_combo | def _create_font_choice_combo(self):
"""Creates font choice combo box"""
self.fonts = get_font_list()
self.font_choice_combo = \
_widgets.FontChoiceCombobox(self, choices=self.fonts,
style=wx.CB_READONLY, size=(125, -1))
self.font_choice_combo.SetToolTipString(_(u"Text font"))
self.AddControl(self.font_choice_combo)
self.Bind(wx.EVT_COMBOBOX, self.OnTextFont, self.font_choice_combo)
self.parent.Bind(self.EVT_CMD_TOOLBAR_UPDATE, self.OnUpdate) | python | def _create_font_choice_combo(self):
"""Creates font choice combo box"""
self.fonts = get_font_list()
self.font_choice_combo = \
_widgets.FontChoiceCombobox(self, choices=self.fonts,
style=wx.CB_READONLY, size=(125, -1))
self.font_choice_combo.SetToolTipString(_(u"Text font"))
self.AddControl(self.font_choice_combo)
self.Bind(wx.EVT_COMBOBOX, self.OnTextFont, self.font_choice_combo)
self.parent.Bind(self.EVT_CMD_TOOLBAR_UPDATE, self.OnUpdate) | [
"def",
"_create_font_choice_combo",
"(",
"self",
")",
":",
"self",
".",
"fonts",
"=",
"get_font_list",
"(",
")",
"self",
".",
"font_choice_combo",
"=",
"_widgets",
".",
"FontChoiceCombobox",
"(",
"self",
",",
"choices",
"=",
"self",
".",
"fonts",
",",
"style... | Creates font choice combo box | [
"Creates",
"font",
"choice",
"combo",
"box"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L561-L574 | train | 231,138 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar._create_font_size_combo | def _create_font_size_combo(self):
"""Creates font size combo box"""
self.std_font_sizes = config["font_default_sizes"]
font_size = str(get_default_font().GetPointSize())
self.font_size_combo = \
wx.ComboBox(self, -1, value=font_size, size=(60, -1),
choices=map(unicode, self.std_font_sizes),
style=wx.CB_DROPDOWN | wx.TE_PROCESS_ENTER)
self.font_size_combo.SetToolTipString(_(u"Text size\n(points)"))
self.AddControl(self.font_size_combo)
self.Bind(wx.EVT_COMBOBOX, self.OnTextSize, self.font_size_combo)
self.Bind(wx.EVT_TEXT_ENTER, self.OnTextSize, self.font_size_combo) | python | def _create_font_size_combo(self):
"""Creates font size combo box"""
self.std_font_sizes = config["font_default_sizes"]
font_size = str(get_default_font().GetPointSize())
self.font_size_combo = \
wx.ComboBox(self, -1, value=font_size, size=(60, -1),
choices=map(unicode, self.std_font_sizes),
style=wx.CB_DROPDOWN | wx.TE_PROCESS_ENTER)
self.font_size_combo.SetToolTipString(_(u"Text size\n(points)"))
self.AddControl(self.font_size_combo)
self.Bind(wx.EVT_COMBOBOX, self.OnTextSize, self.font_size_combo)
self.Bind(wx.EVT_TEXT_ENTER, self.OnTextSize, self.font_size_combo) | [
"def",
"_create_font_size_combo",
"(",
"self",
")",
":",
"self",
".",
"std_font_sizes",
"=",
"config",
"[",
"\"font_default_sizes\"",
"]",
"font_size",
"=",
"str",
"(",
"get_default_font",
"(",
")",
".",
"GetPointSize",
"(",
")",
")",
"self",
".",
"font_size_c... | Creates font size combo box | [
"Creates",
"font",
"size",
"combo",
"box"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L576-L590 | train | 231,139 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar._create_font_face_buttons | def _create_font_face_buttons(self):
"""Creates font face buttons"""
font_face_buttons = [
(wx.FONTFLAG_BOLD, "OnBold", "FormatTextBold", _("Bold")),
(wx.FONTFLAG_ITALIC, "OnItalics", "FormatTextItalic",
_("Italics")),
(wx.FONTFLAG_UNDERLINED, "OnUnderline", "FormatTextUnderline",
_("Underline")),
(wx.FONTFLAG_STRIKETHROUGH, "OnStrikethrough",
"FormatTextStrikethrough", _("Strikethrough")),
(wx.FONTFLAG_MASK, "OnFreeze", "Freeze", _("Freeze")),
(wx.FONTFLAG_NOT_ANTIALIASED, "OnLock", "Lock", _("Lock cell")),
(wx.FONTFAMILY_DECORATIVE, "OnMarkup", "Markup", _("Markup")),
]
for __id, method, iconname, helpstring in font_face_buttons:
bmp = icons[iconname]
self.AddCheckTool(__id, iconname, bmp, bmp,
short_help_string=helpstring)
self.Bind(wx.EVT_TOOL, getattr(self, method), id=__id) | python | def _create_font_face_buttons(self):
"""Creates font face buttons"""
font_face_buttons = [
(wx.FONTFLAG_BOLD, "OnBold", "FormatTextBold", _("Bold")),
(wx.FONTFLAG_ITALIC, "OnItalics", "FormatTextItalic",
_("Italics")),
(wx.FONTFLAG_UNDERLINED, "OnUnderline", "FormatTextUnderline",
_("Underline")),
(wx.FONTFLAG_STRIKETHROUGH, "OnStrikethrough",
"FormatTextStrikethrough", _("Strikethrough")),
(wx.FONTFLAG_MASK, "OnFreeze", "Freeze", _("Freeze")),
(wx.FONTFLAG_NOT_ANTIALIASED, "OnLock", "Lock", _("Lock cell")),
(wx.FONTFAMILY_DECORATIVE, "OnMarkup", "Markup", _("Markup")),
]
for __id, method, iconname, helpstring in font_face_buttons:
bmp = icons[iconname]
self.AddCheckTool(__id, iconname, bmp, bmp,
short_help_string=helpstring)
self.Bind(wx.EVT_TOOL, getattr(self, method), id=__id) | [
"def",
"_create_font_face_buttons",
"(",
"self",
")",
":",
"font_face_buttons",
"=",
"[",
"(",
"wx",
".",
"FONTFLAG_BOLD",
",",
"\"OnBold\"",
",",
"\"FormatTextBold\"",
",",
"_",
"(",
"\"Bold\"",
")",
")",
",",
"(",
"wx",
".",
"FONTFLAG_ITALIC",
",",
"\"OnIt... | Creates font face buttons | [
"Creates",
"font",
"face",
"buttons"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L592-L612 | train | 231,140 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar._create_textrotation_button | def _create_textrotation_button(self):
"""Create text rotation toggle button"""
iconnames = ["TextRotate270", "TextRotate0", "TextRotate90",
"TextRotate180"]
bmplist = [icons[iconname] for iconname in iconnames]
self.rotation_tb = _widgets.BitmapToggleButton(self, bmplist)
self.rotation_tb.SetToolTipString(_(u"Cell text rotation"))
self.Bind(wx.EVT_BUTTON, self.OnRotate, self.rotation_tb)
self.AddControl(self.rotation_tb) | python | def _create_textrotation_button(self):
"""Create text rotation toggle button"""
iconnames = ["TextRotate270", "TextRotate0", "TextRotate90",
"TextRotate180"]
bmplist = [icons[iconname] for iconname in iconnames]
self.rotation_tb = _widgets.BitmapToggleButton(self, bmplist)
self.rotation_tb.SetToolTipString(_(u"Cell text rotation"))
self.Bind(wx.EVT_BUTTON, self.OnRotate, self.rotation_tb)
self.AddControl(self.rotation_tb) | [
"def",
"_create_textrotation_button",
"(",
"self",
")",
":",
"iconnames",
"=",
"[",
"\"TextRotate270\"",
",",
"\"TextRotate0\"",
",",
"\"TextRotate90\"",
",",
"\"TextRotate180\"",
"]",
"bmplist",
"=",
"[",
"icons",
"[",
"iconname",
"]",
"for",
"iconname",
"in",
... | Create text rotation toggle button | [
"Create",
"text",
"rotation",
"toggle",
"button"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L614-L624 | train | 231,141 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar._create_justification_button | def _create_justification_button(self):
"""Creates horizontal justification button"""
iconnames = ["JustifyLeft", "JustifyCenter", "JustifyRight"]
bmplist = [icons[iconname] for iconname in iconnames]
self.justify_tb = _widgets.BitmapToggleButton(self, bmplist)
self.justify_tb.SetToolTipString(_(u"Justification"))
self.Bind(wx.EVT_BUTTON, self.OnJustification, self.justify_tb)
self.AddControl(self.justify_tb) | python | def _create_justification_button(self):
"""Creates horizontal justification button"""
iconnames = ["JustifyLeft", "JustifyCenter", "JustifyRight"]
bmplist = [icons[iconname] for iconname in iconnames]
self.justify_tb = _widgets.BitmapToggleButton(self, bmplist)
self.justify_tb.SetToolTipString(_(u"Justification"))
self.Bind(wx.EVT_BUTTON, self.OnJustification, self.justify_tb)
self.AddControl(self.justify_tb) | [
"def",
"_create_justification_button",
"(",
"self",
")",
":",
"iconnames",
"=",
"[",
"\"JustifyLeft\"",
",",
"\"JustifyCenter\"",
",",
"\"JustifyRight\"",
"]",
"bmplist",
"=",
"[",
"icons",
"[",
"iconname",
"]",
"for",
"iconname",
"in",
"iconnames",
"]",
"self",... | Creates horizontal justification button | [
"Creates",
"horizontal",
"justification",
"button"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L626-L634 | train | 231,142 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar._create_alignment_button | def _create_alignment_button(self):
"""Creates vertical alignment button"""
iconnames = ["AlignTop", "AlignCenter", "AlignBottom"]
bmplist = [icons[iconname] for iconname in iconnames]
self.alignment_tb = _widgets.BitmapToggleButton(self, bmplist)
self.alignment_tb.SetToolTipString(_(u"Alignment"))
self.Bind(wx.EVT_BUTTON, self.OnAlignment, self.alignment_tb)
self.AddControl(self.alignment_tb) | python | def _create_alignment_button(self):
"""Creates vertical alignment button"""
iconnames = ["AlignTop", "AlignCenter", "AlignBottom"]
bmplist = [icons[iconname] for iconname in iconnames]
self.alignment_tb = _widgets.BitmapToggleButton(self, bmplist)
self.alignment_tb.SetToolTipString(_(u"Alignment"))
self.Bind(wx.EVT_BUTTON, self.OnAlignment, self.alignment_tb)
self.AddControl(self.alignment_tb) | [
"def",
"_create_alignment_button",
"(",
"self",
")",
":",
"iconnames",
"=",
"[",
"\"AlignTop\"",
",",
"\"AlignCenter\"",
",",
"\"AlignBottom\"",
"]",
"bmplist",
"=",
"[",
"icons",
"[",
"iconname",
"]",
"for",
"iconname",
"in",
"iconnames",
"]",
"self",
".",
... | Creates vertical alignment button | [
"Creates",
"vertical",
"alignment",
"button"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L636-L645 | train | 231,143 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar._create_borderchoice_combo | def _create_borderchoice_combo(self):
"""Create border choice combo box"""
choices = [c[0] for c in self.border_toggles]
self.borderchoice_combo = \
_widgets.BorderEditChoice(self, choices=choices,
style=wx.CB_READONLY, size=(50, -1))
self.borderchoice_combo.SetToolTipString(
_(u"Choose borders for which attributes are changed"))
self.borderstate = self.border_toggles[0][0]
self.AddControl(self.borderchoice_combo)
self.Bind(wx.EVT_COMBOBOX, self.OnBorderChoice,
self.borderchoice_combo)
self.borderchoice_combo.SetValue("AllBorders") | python | def _create_borderchoice_combo(self):
"""Create border choice combo box"""
choices = [c[0] for c in self.border_toggles]
self.borderchoice_combo = \
_widgets.BorderEditChoice(self, choices=choices,
style=wx.CB_READONLY, size=(50, -1))
self.borderchoice_combo.SetToolTipString(
_(u"Choose borders for which attributes are changed"))
self.borderstate = self.border_toggles[0][0]
self.AddControl(self.borderchoice_combo)
self.Bind(wx.EVT_COMBOBOX, self.OnBorderChoice,
self.borderchoice_combo)
self.borderchoice_combo.SetValue("AllBorders") | [
"def",
"_create_borderchoice_combo",
"(",
"self",
")",
":",
"choices",
"=",
"[",
"c",
"[",
"0",
"]",
"for",
"c",
"in",
"self",
".",
"border_toggles",
"]",
"self",
".",
"borderchoice_combo",
"=",
"_widgets",
".",
"BorderEditChoice",
"(",
"self",
",",
"choic... | Create border choice combo box | [
"Create",
"border",
"choice",
"combo",
"box"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L647-L665 | train | 231,144 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar._create_penwidth_combo | def _create_penwidth_combo(self):
"""Create pen width combo box"""
choices = map(unicode, xrange(12))
self.pen_width_combo = \
_widgets.PenWidthComboBox(self, choices=choices,
style=wx.CB_READONLY, size=(50, -1))
self.pen_width_combo.SetToolTipString(_(u"Border width"))
self.AddControl(self.pen_width_combo)
self.Bind(wx.EVT_COMBOBOX, self.OnLineWidth, self.pen_width_combo) | python | def _create_penwidth_combo(self):
"""Create pen width combo box"""
choices = map(unicode, xrange(12))
self.pen_width_combo = \
_widgets.PenWidthComboBox(self, choices=choices,
style=wx.CB_READONLY, size=(50, -1))
self.pen_width_combo.SetToolTipString(_(u"Border width"))
self.AddControl(self.pen_width_combo)
self.Bind(wx.EVT_COMBOBOX, self.OnLineWidth, self.pen_width_combo) | [
"def",
"_create_penwidth_combo",
"(",
"self",
")",
":",
"choices",
"=",
"map",
"(",
"unicode",
",",
"xrange",
"(",
"12",
")",
")",
"self",
".",
"pen_width_combo",
"=",
"_widgets",
".",
"PenWidthComboBox",
"(",
"self",
",",
"choices",
"=",
"choices",
",",
... | Create pen width combo box | [
"Create",
"pen",
"width",
"combo",
"box"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L667-L677 | train | 231,145 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar._create_color_buttons | def _create_color_buttons(self):
"""Create color choice buttons"""
button_size = (30, 30)
button_style = wx.NO_BORDER
try:
self.linecolor_choice = \
csel.ColourSelect(self, -1, unichr(0x2500), (0, 0, 0),
size=button_size, style=button_style)
except UnicodeEncodeError:
# ANSI wxPython installed
self.linecolor_choice = \
csel.ColourSelect(self, -1, "-", (0, 0, 0),
size=button_size, style=button_style)
self.bgcolor_choice = \
csel.ColourSelect(self, -1, "", (255, 255, 255),
size=button_size, style=button_style)
self.textcolor_choice = \
csel.ColourSelect(self, -1, "A", (0, 0, 0),
size=button_size, style=button_style)
self.linecolor_choice.SetToolTipString(_(u"Border line color"))
self.bgcolor_choice.SetToolTipString(_(u"Cell background"))
self.textcolor_choice.SetToolTipString(_(u"Text color"))
self.AddControl(self.linecolor_choice)
self.AddControl(self.bgcolor_choice)
self.AddControl(self.textcolor_choice)
self.linecolor_choice.Bind(csel.EVT_COLOURSELECT, self.OnLineColor)
self.bgcolor_choice.Bind(csel.EVT_COLOURSELECT, self.OnBGColor)
self.textcolor_choice.Bind(csel.EVT_COLOURSELECT, self.OnTextColor) | python | def _create_color_buttons(self):
"""Create color choice buttons"""
button_size = (30, 30)
button_style = wx.NO_BORDER
try:
self.linecolor_choice = \
csel.ColourSelect(self, -1, unichr(0x2500), (0, 0, 0),
size=button_size, style=button_style)
except UnicodeEncodeError:
# ANSI wxPython installed
self.linecolor_choice = \
csel.ColourSelect(self, -1, "-", (0, 0, 0),
size=button_size, style=button_style)
self.bgcolor_choice = \
csel.ColourSelect(self, -1, "", (255, 255, 255),
size=button_size, style=button_style)
self.textcolor_choice = \
csel.ColourSelect(self, -1, "A", (0, 0, 0),
size=button_size, style=button_style)
self.linecolor_choice.SetToolTipString(_(u"Border line color"))
self.bgcolor_choice.SetToolTipString(_(u"Cell background"))
self.textcolor_choice.SetToolTipString(_(u"Text color"))
self.AddControl(self.linecolor_choice)
self.AddControl(self.bgcolor_choice)
self.AddControl(self.textcolor_choice)
self.linecolor_choice.Bind(csel.EVT_COLOURSELECT, self.OnLineColor)
self.bgcolor_choice.Bind(csel.EVT_COLOURSELECT, self.OnBGColor)
self.textcolor_choice.Bind(csel.EVT_COLOURSELECT, self.OnTextColor) | [
"def",
"_create_color_buttons",
"(",
"self",
")",
":",
"button_size",
"=",
"(",
"30",
",",
"30",
")",
"button_style",
"=",
"wx",
".",
"NO_BORDER",
"try",
":",
"self",
".",
"linecolor_choice",
"=",
"csel",
".",
"ColourSelect",
"(",
"self",
",",
"-",
"1",
... | Create color choice buttons | [
"Create",
"color",
"choice",
"buttons"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L679-L712 | train | 231,146 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar._create_merge_button | def _create_merge_button(self):
"""Create merge button"""
bmp = icons["Merge"]
self.mergetool_id = wx.NewId()
self.AddCheckTool(self.mergetool_id, "Merge", bmp, bmp,
short_help_string=_("Merge cells"))
self.Bind(wx.EVT_TOOL, self.OnMerge, id=self.mergetool_id) | python | def _create_merge_button(self):
"""Create merge button"""
bmp = icons["Merge"]
self.mergetool_id = wx.NewId()
self.AddCheckTool(self.mergetool_id, "Merge", bmp, bmp,
short_help_string=_("Merge cells"))
self.Bind(wx.EVT_TOOL, self.OnMerge, id=self.mergetool_id) | [
"def",
"_create_merge_button",
"(",
"self",
")",
":",
"bmp",
"=",
"icons",
"[",
"\"Merge\"",
"]",
"self",
".",
"mergetool_id",
"=",
"wx",
".",
"NewId",
"(",
")",
"self",
".",
"AddCheckTool",
"(",
"self",
".",
"mergetool_id",
",",
"\"Merge\"",
",",
"bmp",... | Create merge button | [
"Create",
"merge",
"button"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L714-L721 | train | 231,147 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar._update_font | def _update_font(self, textfont):
"""Updates text font widget
Parameters
----------
textfont: String
\tFont name
"""
try:
fontface_id = self.fonts.index(textfont)
except ValueError:
fontface_id = 0
self.font_choice_combo.Select(fontface_id) | python | def _update_font(self, textfont):
"""Updates text font widget
Parameters
----------
textfont: String
\tFont name
"""
try:
fontface_id = self.fonts.index(textfont)
except ValueError:
fontface_id = 0
self.font_choice_combo.Select(fontface_id) | [
"def",
"_update_font",
"(",
"self",
",",
"textfont",
")",
":",
"try",
":",
"fontface_id",
"=",
"self",
".",
"fonts",
".",
"index",
"(",
"textfont",
")",
"except",
"ValueError",
":",
"fontface_id",
"=",
"0",
"self",
".",
"font_choice_combo",
".",
"Select",
... | Updates text font widget
Parameters
----------
textfont: String
\tFont name | [
"Updates",
"text",
"font",
"widget"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L726-L742 | train | 231,148 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar._update_font_weight | def _update_font_weight(self, font_weight):
"""Updates font weight widget
Parameters
----------
font_weight: Integer
\tButton down iif font_weight == wx.FONTWEIGHT_BOLD
"""
toggle_state = font_weight & wx.FONTWEIGHT_BOLD == wx.FONTWEIGHT_BOLD
self.ToggleTool(wx.FONTFLAG_BOLD, toggle_state) | python | def _update_font_weight(self, font_weight):
"""Updates font weight widget
Parameters
----------
font_weight: Integer
\tButton down iif font_weight == wx.FONTWEIGHT_BOLD
"""
toggle_state = font_weight & wx.FONTWEIGHT_BOLD == wx.FONTWEIGHT_BOLD
self.ToggleTool(wx.FONTFLAG_BOLD, toggle_state) | [
"def",
"_update_font_weight",
"(",
"self",
",",
"font_weight",
")",
":",
"toggle_state",
"=",
"font_weight",
"&",
"wx",
".",
"FONTWEIGHT_BOLD",
"==",
"wx",
".",
"FONTWEIGHT_BOLD",
"self",
".",
"ToggleTool",
"(",
"wx",
".",
"FONTFLAG_BOLD",
",",
"toggle_state",
... | Updates font weight widget
Parameters
----------
font_weight: Integer
\tButton down iif font_weight == wx.FONTWEIGHT_BOLD | [
"Updates",
"font",
"weight",
"widget"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L757-L770 | train | 231,149 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar._update_font_style | def _update_font_style(self, font_style):
"""Updates font style widget
Parameters
----------
font_style: Integer
\tButton down iif font_style == wx.FONTSTYLE_ITALIC
"""
toggle_state = font_style & wx.FONTSTYLE_ITALIC == wx.FONTSTYLE_ITALIC
self.ToggleTool(wx.FONTFLAG_ITALIC, toggle_state) | python | def _update_font_style(self, font_style):
"""Updates font style widget
Parameters
----------
font_style: Integer
\tButton down iif font_style == wx.FONTSTYLE_ITALIC
"""
toggle_state = font_style & wx.FONTSTYLE_ITALIC == wx.FONTSTYLE_ITALIC
self.ToggleTool(wx.FONTFLAG_ITALIC, toggle_state) | [
"def",
"_update_font_style",
"(",
"self",
",",
"font_style",
")",
":",
"toggle_state",
"=",
"font_style",
"&",
"wx",
".",
"FONTSTYLE_ITALIC",
"==",
"wx",
".",
"FONTSTYLE_ITALIC",
"self",
".",
"ToggleTool",
"(",
"wx",
".",
"FONTFLAG_ITALIC",
",",
"toggle_state",
... | Updates font style widget
Parameters
----------
font_style: Integer
\tButton down iif font_style == wx.FONTSTYLE_ITALIC | [
"Updates",
"font",
"style",
"widget"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L772-L785 | train | 231,150 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar._update_frozencell | def _update_frozencell(self, frozen):
"""Updates frozen cell widget
Parameters
----------
frozen: Bool or string
\tUntoggled iif False
"""
toggle_state = frozen is not False
self.ToggleTool(wx.FONTFLAG_MASK, toggle_state) | python | def _update_frozencell(self, frozen):
"""Updates frozen cell widget
Parameters
----------
frozen: Bool or string
\tUntoggled iif False
"""
toggle_state = frozen is not False
self.ToggleTool(wx.FONTFLAG_MASK, toggle_state) | [
"def",
"_update_frozencell",
"(",
"self",
",",
"frozen",
")",
":",
"toggle_state",
"=",
"frozen",
"is",
"not",
"False",
"self",
".",
"ToggleTool",
"(",
"wx",
".",
"FONTFLAG_MASK",
",",
"toggle_state",
")"
] | Updates frozen cell widget
Parameters
----------
frozen: Bool or string
\tUntoggled iif False | [
"Updates",
"frozen",
"cell",
"widget"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L787-L800 | train | 231,151 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar._update_textrotation | def _update_textrotation(self, angle):
"""Updates text rotation toggle button"""
states = {0: 0, -90: 1, 180: 2, 90: 3}
try:
self.rotation_tb.state = states[round(angle)]
except KeyError:
self.rotation_tb.state = 0
self.rotation_tb.toggle(None)
self.rotation_tb.Refresh() | python | def _update_textrotation(self, angle):
"""Updates text rotation toggle button"""
states = {0: 0, -90: 1, 180: 2, 90: 3}
try:
self.rotation_tb.state = states[round(angle)]
except KeyError:
self.rotation_tb.state = 0
self.rotation_tb.toggle(None)
self.rotation_tb.Refresh() | [
"def",
"_update_textrotation",
"(",
"self",
",",
"angle",
")",
":",
"states",
"=",
"{",
"0",
":",
"0",
",",
"-",
"90",
":",
"1",
",",
"180",
":",
"2",
",",
"90",
":",
"3",
"}",
"try",
":",
"self",
".",
"rotation_tb",
".",
"state",
"=",
"states"... | Updates text rotation toggle button | [
"Updates",
"text",
"rotation",
"toggle",
"button"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L854-L865 | train | 231,152 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar._update_justification | def _update_justification(self, justification):
"""Updates horizontal text justification button
Parameters
----------
justification: String in ["left", "center", "right"]
\tSwitches button to untoggled if False and toggled if True
"""
states = {"left": 2, "center": 0, "right": 1}
self.justify_tb.state = states[justification]
self.justify_tb.toggle(None)
self.justify_tb.Refresh() | python | def _update_justification(self, justification):
"""Updates horizontal text justification button
Parameters
----------
justification: String in ["left", "center", "right"]
\tSwitches button to untoggled if False and toggled if True
"""
states = {"left": 2, "center": 0, "right": 1}
self.justify_tb.state = states[justification]
self.justify_tb.toggle(None)
self.justify_tb.Refresh() | [
"def",
"_update_justification",
"(",
"self",
",",
"justification",
")",
":",
"states",
"=",
"{",
"\"left\"",
":",
"2",
",",
"\"center\"",
":",
"0",
",",
"\"right\"",
":",
"1",
"}",
"self",
".",
"justify_tb",
".",
"state",
"=",
"states",
"[",
"justificati... | Updates horizontal text justification button
Parameters
----------
justification: String in ["left", "center", "right"]
\tSwitches button to untoggled if False and toggled if True | [
"Updates",
"horizontal",
"text",
"justification",
"button"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L867-L883 | train | 231,153 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar._update_alignment | def _update_alignment(self, alignment):
"""Updates vertical text alignment button
Parameters
----------
alignment: String in ["top", "middle", "right"]
\tSwitches button to untoggled if False and toggled if True
"""
states = {"top": 2, "middle": 0, "bottom": 1}
self.alignment_tb.state = states[alignment]
self.alignment_tb.toggle(None)
self.alignment_tb.Refresh() | python | def _update_alignment(self, alignment):
"""Updates vertical text alignment button
Parameters
----------
alignment: String in ["top", "middle", "right"]
\tSwitches button to untoggled if False and toggled if True
"""
states = {"top": 2, "middle": 0, "bottom": 1}
self.alignment_tb.state = states[alignment]
self.alignment_tb.toggle(None)
self.alignment_tb.Refresh() | [
"def",
"_update_alignment",
"(",
"self",
",",
"alignment",
")",
":",
"states",
"=",
"{",
"\"top\"",
":",
"2",
",",
"\"middle\"",
":",
"0",
",",
"\"bottom\"",
":",
"1",
"}",
"self",
".",
"alignment_tb",
".",
"state",
"=",
"states",
"[",
"alignment",
"]"... | Updates vertical text alignment button
Parameters
----------
alignment: String in ["top", "middle", "right"]
\tSwitches button to untoggled if False and toggled if True | [
"Updates",
"vertical",
"text",
"alignment",
"button"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L885-L901 | train | 231,154 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar._update_fontcolor | def _update_fontcolor(self, fontcolor):
"""Updates text font color button
Parameters
----------
fontcolor: Integer
\tText color in integer RGB format
"""
textcolor = wx.SystemSettings_GetColour(wx.SYS_COLOUR_WINDOWTEXT)
textcolor.SetRGB(fontcolor)
self.textcolor_choice.SetColour(textcolor) | python | def _update_fontcolor(self, fontcolor):
"""Updates text font color button
Parameters
----------
fontcolor: Integer
\tText color in integer RGB format
"""
textcolor = wx.SystemSettings_GetColour(wx.SYS_COLOUR_WINDOWTEXT)
textcolor.SetRGB(fontcolor)
self.textcolor_choice.SetColour(textcolor) | [
"def",
"_update_fontcolor",
"(",
"self",
",",
"fontcolor",
")",
":",
"textcolor",
"=",
"wx",
".",
"SystemSettings_GetColour",
"(",
"wx",
".",
"SYS_COLOUR_WINDOWTEXT",
")",
"textcolor",
".",
"SetRGB",
"(",
"fontcolor",
")",
"self",
".",
"textcolor_choice",
".",
... | Updates text font color button
Parameters
----------
fontcolor: Integer
\tText color in integer RGB format | [
"Updates",
"text",
"font",
"color",
"button"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L903-L917 | train | 231,155 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar.OnBorderChoice | def OnBorderChoice(self, event):
"""Change the borders that are affected by color and width changes"""
choicelist = event.GetEventObject().GetItems()
self.borderstate = choicelist[event.GetInt()] | python | def OnBorderChoice(self, event):
"""Change the borders that are affected by color and width changes"""
choicelist = event.GetEventObject().GetItems()
self.borderstate = choicelist[event.GetInt()] | [
"def",
"OnBorderChoice",
"(",
"self",
",",
"event",
")",
":",
"choicelist",
"=",
"event",
".",
"GetEventObject",
"(",
")",
".",
"GetItems",
"(",
")",
"self",
".",
"borderstate",
"=",
"choicelist",
"[",
"event",
".",
"GetInt",
"(",
")",
"]"
] | Change the borders that are affected by color and width changes | [
"Change",
"the",
"borders",
"that",
"are",
"affected",
"by",
"color",
"and",
"width",
"changes"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L975-L979 | train | 231,156 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar.OnLineColor | def OnLineColor(self, event):
"""Line color choice event handler"""
color = event.GetValue().GetRGB()
borders = self.bordermap[self.borderstate]
post_command_event(self, self.BorderColorMsg, color=color,
borders=borders) | python | def OnLineColor(self, event):
"""Line color choice event handler"""
color = event.GetValue().GetRGB()
borders = self.bordermap[self.borderstate]
post_command_event(self, self.BorderColorMsg, color=color,
borders=borders) | [
"def",
"OnLineColor",
"(",
"self",
",",
"event",
")",
":",
"color",
"=",
"event",
".",
"GetValue",
"(",
")",
".",
"GetRGB",
"(",
")",
"borders",
"=",
"self",
".",
"bordermap",
"[",
"self",
".",
"borderstate",
"]",
"post_command_event",
"(",
"self",
","... | Line color choice event handler | [
"Line",
"color",
"choice",
"event",
"handler"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L981-L988 | train | 231,157 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar.OnLineWidth | def OnLineWidth(self, event):
"""Line width choice event handler"""
linewidth_combobox = event.GetEventObject()
idx = event.GetInt()
width = int(linewidth_combobox.GetString(idx))
borders = self.bordermap[self.borderstate]
post_command_event(self, self.BorderWidthMsg, width=width,
borders=borders) | python | def OnLineWidth(self, event):
"""Line width choice event handler"""
linewidth_combobox = event.GetEventObject()
idx = event.GetInt()
width = int(linewidth_combobox.GetString(idx))
borders = self.bordermap[self.borderstate]
post_command_event(self, self.BorderWidthMsg, width=width,
borders=borders) | [
"def",
"OnLineWidth",
"(",
"self",
",",
"event",
")",
":",
"linewidth_combobox",
"=",
"event",
".",
"GetEventObject",
"(",
")",
"idx",
"=",
"event",
".",
"GetInt",
"(",
")",
"width",
"=",
"int",
"(",
"linewidth_combobox",
".",
"GetString",
"(",
"idx",
")... | Line width choice event handler | [
"Line",
"width",
"choice",
"event",
"handler"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L990-L999 | train | 231,158 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar.OnBGColor | def OnBGColor(self, event):
"""Background color choice event handler"""
color = event.GetValue().GetRGB()
post_command_event(self, self.BackgroundColorMsg, color=color) | python | def OnBGColor(self, event):
"""Background color choice event handler"""
color = event.GetValue().GetRGB()
post_command_event(self, self.BackgroundColorMsg, color=color) | [
"def",
"OnBGColor",
"(",
"self",
",",
"event",
")",
":",
"color",
"=",
"event",
".",
"GetValue",
"(",
")",
".",
"GetRGB",
"(",
")",
"post_command_event",
"(",
"self",
",",
"self",
".",
"BackgroundColorMsg",
",",
"color",
"=",
"color",
")"
] | Background color choice event handler | [
"Background",
"color",
"choice",
"event",
"handler"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L1001-L1006 | train | 231,159 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar.OnTextColor | def OnTextColor(self, event):
"""Text color choice event handler"""
color = event.GetValue().GetRGB()
post_command_event(self, self.TextColorMsg, color=color) | python | def OnTextColor(self, event):
"""Text color choice event handler"""
color = event.GetValue().GetRGB()
post_command_event(self, self.TextColorMsg, color=color) | [
"def",
"OnTextColor",
"(",
"self",
",",
"event",
")",
":",
"color",
"=",
"event",
".",
"GetValue",
"(",
")",
".",
"GetRGB",
"(",
")",
"post_command_event",
"(",
"self",
",",
"self",
".",
"TextColorMsg",
",",
"color",
"=",
"color",
")"
] | Text color choice event handler | [
"Text",
"color",
"choice",
"event",
"handler"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L1008-L1013 | train | 231,160 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar.OnTextFont | def OnTextFont(self, event):
"""Text font choice event handler"""
fontchoice_combobox = event.GetEventObject()
idx = event.GetInt()
try:
font_string = fontchoice_combobox.GetString(idx)
except AttributeError:
font_string = event.GetString()
post_command_event(self, self.FontMsg, font=font_string) | python | def OnTextFont(self, event):
"""Text font choice event handler"""
fontchoice_combobox = event.GetEventObject()
idx = event.GetInt()
try:
font_string = fontchoice_combobox.GetString(idx)
except AttributeError:
font_string = event.GetString()
post_command_event(self, self.FontMsg, font=font_string) | [
"def",
"OnTextFont",
"(",
"self",
",",
"event",
")",
":",
"fontchoice_combobox",
"=",
"event",
".",
"GetEventObject",
"(",
")",
"idx",
"=",
"event",
".",
"GetInt",
"(",
")",
"try",
":",
"font_string",
"=",
"fontchoice_combobox",
".",
"GetString",
"(",
"idx... | Text font choice event handler | [
"Text",
"font",
"choice",
"event",
"handler"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L1015-L1026 | train | 231,161 |
manns/pyspread | pyspread/src/gui/_toolbars.py | AttributesToolbar.OnTextSize | def OnTextSize(self, event):
"""Text size combo text event handler"""
try:
size = int(event.GetString())
except Exception:
size = get_default_font().GetPointSize()
post_command_event(self, self.FontSizeMsg, size=size) | python | def OnTextSize(self, event):
"""Text size combo text event handler"""
try:
size = int(event.GetString())
except Exception:
size = get_default_font().GetPointSize()
post_command_event(self, self.FontSizeMsg, size=size) | [
"def",
"OnTextSize",
"(",
"self",
",",
"event",
")",
":",
"try",
":",
"size",
"=",
"int",
"(",
"event",
".",
"GetString",
"(",
")",
")",
"except",
"Exception",
":",
"size",
"=",
"get_default_font",
"(",
")",
".",
"GetPointSize",
"(",
")",
"post_command... | Text size combo text event handler | [
"Text",
"size",
"combo",
"text",
"event",
"handler"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/gui/_toolbars.py#L1028-L1037 | train | 231,162 |
manns/pyspread | pyspread/src/actions/_grid_cell_actions.py | CellActions.set_code | def set_code(self, key, code):
"""Sets code of cell key, marks grid as changed"""
old_code = self.grid.code_array(key)
try:
old_code = unicode(old_code, encoding="utf-8")
except TypeError:
pass
if code == old_code:
return
if not (old_code is None and not code) and code != old_code:
# Mark content as changed
post_command_event(self.main_window, self.ContentChangedMsg)
# Set cell code
self.grid.code_array.__setitem__(key, code) | python | def set_code(self, key, code):
"""Sets code of cell key, marks grid as changed"""
old_code = self.grid.code_array(key)
try:
old_code = unicode(old_code, encoding="utf-8")
except TypeError:
pass
if code == old_code:
return
if not (old_code is None and not code) and code != old_code:
# Mark content as changed
post_command_event(self.main_window, self.ContentChangedMsg)
# Set cell code
self.grid.code_array.__setitem__(key, code) | [
"def",
"set_code",
"(",
"self",
",",
"key",
",",
"code",
")",
":",
"old_code",
"=",
"self",
".",
"grid",
".",
"code_array",
"(",
"key",
")",
"try",
":",
"old_code",
"=",
"unicode",
"(",
"old_code",
",",
"encoding",
"=",
"\"utf-8\"",
")",
"except",
"T... | Sets code of cell key, marks grid as changed | [
"Sets",
"code",
"of",
"cell",
"key",
"marks",
"grid",
"as",
"changed"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_grid_cell_actions.py#L50-L69 | train | 231,163 |
manns/pyspread | pyspread/src/actions/_grid_cell_actions.py | CellActions.quote_code | def quote_code(self, key):
"""Returns string quoted code """
code = self.grid.code_array(key)
quoted_code = quote(code)
if quoted_code is not None:
self.set_code(key, quoted_code) | python | def quote_code(self, key):
"""Returns string quoted code """
code = self.grid.code_array(key)
quoted_code = quote(code)
if quoted_code is not None:
self.set_code(key, quoted_code) | [
"def",
"quote_code",
"(",
"self",
",",
"key",
")",
":",
"code",
"=",
"self",
".",
"grid",
".",
"code_array",
"(",
"key",
")",
"quoted_code",
"=",
"quote",
"(",
"code",
")",
"if",
"quoted_code",
"is",
"not",
"None",
":",
"self",
".",
"set_code",
"(",
... | Returns string quoted code | [
"Returns",
"string",
"quoted",
"code"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_grid_cell_actions.py#L71-L78 | train | 231,164 |
manns/pyspread | pyspread/src/actions/_grid_cell_actions.py | CellActions.delete_cell | def delete_cell(self, key):
"""Deletes key cell"""
try:
self.code_array.pop(key)
except KeyError:
pass
self.grid.code_array.result_cache.clear() | python | def delete_cell(self, key):
"""Deletes key cell"""
try:
self.code_array.pop(key)
except KeyError:
pass
self.grid.code_array.result_cache.clear() | [
"def",
"delete_cell",
"(",
"self",
",",
"key",
")",
":",
"try",
":",
"self",
".",
"code_array",
".",
"pop",
"(",
"key",
")",
"except",
"KeyError",
":",
"pass",
"self",
".",
"grid",
".",
"code_array",
".",
"result_cache",
".",
"clear",
"(",
")"
] | Deletes key cell | [
"Deletes",
"key",
"cell"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_grid_cell_actions.py#L80-L89 | train | 231,165 |
manns/pyspread | pyspread/src/actions/_grid_cell_actions.py | CellActions.append_reference_code | def append_reference_code(self, key, ref_key, ref_type="absolute"):
"""Appends reference code to cell code.
Replaces existing reference.
Parameters
----------
key: 3-tuple of Integer
\tKey of cell that gets the reference
ref_key: 3-tuple of Integer
\tKey of cell that is referenced
ref_type: Sting in ["absolute", "relative"]
\tAn absolute or a relative reference is added
"""
if ref_type == "absolute":
code = self._get_absolute_reference(ref_key)
elif ref_type == "relative":
code = self._get_relative_reference(key, ref_key)
else:
raise ValueError(_('ref_type has to be "absolute" or "relative".'))
old_code = self.grid.code_array(key)
if old_code is None:
old_code = u""
if "S" in old_code and old_code[-1] == "]":
old_code_left, __ = old_code.rsplit("S", 1)
new_code = old_code_left + code
else:
new_code = old_code + code
post_command_event(self.grid.main_window, self.EntryLineMsg,
text=new_code)
return new_code | python | def append_reference_code(self, key, ref_key, ref_type="absolute"):
"""Appends reference code to cell code.
Replaces existing reference.
Parameters
----------
key: 3-tuple of Integer
\tKey of cell that gets the reference
ref_key: 3-tuple of Integer
\tKey of cell that is referenced
ref_type: Sting in ["absolute", "relative"]
\tAn absolute or a relative reference is added
"""
if ref_type == "absolute":
code = self._get_absolute_reference(ref_key)
elif ref_type == "relative":
code = self._get_relative_reference(key, ref_key)
else:
raise ValueError(_('ref_type has to be "absolute" or "relative".'))
old_code = self.grid.code_array(key)
if old_code is None:
old_code = u""
if "S" in old_code and old_code[-1] == "]":
old_code_left, __ = old_code.rsplit("S", 1)
new_code = old_code_left + code
else:
new_code = old_code + code
post_command_event(self.grid.main_window, self.EntryLineMsg,
text=new_code)
return new_code | [
"def",
"append_reference_code",
"(",
"self",
",",
"key",
",",
"ref_key",
",",
"ref_type",
"=",
"\"absolute\"",
")",
":",
"if",
"ref_type",
"==",
"\"absolute\"",
":",
"code",
"=",
"self",
".",
"_get_absolute_reference",
"(",
"ref_key",
")",
"elif",
"ref_type",
... | Appends reference code to cell code.
Replaces existing reference.
Parameters
----------
key: 3-tuple of Integer
\tKey of cell that gets the reference
ref_key: 3-tuple of Integer
\tKey of cell that is referenced
ref_type: Sting in ["absolute", "relative"]
\tAn absolute or a relative reference is added | [
"Appends",
"reference",
"code",
"to",
"cell",
"code",
"."
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_grid_cell_actions.py#L145-L184 | train | 231,166 |
manns/pyspread | pyspread/src/actions/_grid_cell_actions.py | CellActions._set_cell_attr | def _set_cell_attr(self, selection, table, attr):
"""Sets cell attr for key cell and mark grid content as changed
Parameters
----------
attr: dict
\tContains cell attribute keys
\tkeys in ["borderwidth_bottom", "borderwidth_right",
\t"bordercolor_bottom", "bordercolor_right",
\t"bgcolor", "textfont",
\t"pointsize", "fontweight", "fontstyle", "textcolor", "underline",
\t"strikethrough", "angle", "column-width", "row-height",
\t"vertical_align", "justification", "frozen", "merge_area"]
"""
# Mark content as changed
post_command_event(self.main_window, self.ContentChangedMsg)
if selection is not None:
self.code_array.cell_attributes.append((selection, table, attr)) | python | def _set_cell_attr(self, selection, table, attr):
"""Sets cell attr for key cell and mark grid content as changed
Parameters
----------
attr: dict
\tContains cell attribute keys
\tkeys in ["borderwidth_bottom", "borderwidth_right",
\t"bordercolor_bottom", "bordercolor_right",
\t"bgcolor", "textfont",
\t"pointsize", "fontweight", "fontstyle", "textcolor", "underline",
\t"strikethrough", "angle", "column-width", "row-height",
\t"vertical_align", "justification", "frozen", "merge_area"]
"""
# Mark content as changed
post_command_event(self.main_window, self.ContentChangedMsg)
if selection is not None:
self.code_array.cell_attributes.append((selection, table, attr)) | [
"def",
"_set_cell_attr",
"(",
"self",
",",
"selection",
",",
"table",
",",
"attr",
")",
":",
"# Mark content as changed",
"post_command_event",
"(",
"self",
".",
"main_window",
",",
"self",
".",
"ContentChangedMsg",
")",
"if",
"selection",
"is",
"not",
"None",
... | Sets cell attr for key cell and mark grid content as changed
Parameters
----------
attr: dict
\tContains cell attribute keys
\tkeys in ["borderwidth_bottom", "borderwidth_right",
\t"bordercolor_bottom", "bordercolor_right",
\t"bgcolor", "textfont",
\t"pointsize", "fontweight", "fontstyle", "textcolor", "underline",
\t"strikethrough", "angle", "column-width", "row-height",
\t"vertical_align", "justification", "frozen", "merge_area"] | [
"Sets",
"cell",
"attr",
"for",
"key",
"cell",
"and",
"mark",
"grid",
"content",
"as",
"changed"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_grid_cell_actions.py#L186-L207 | train | 231,167 |
manns/pyspread | pyspread/src/actions/_grid_cell_actions.py | CellActions.set_attr | def set_attr(self, attr, value, selection=None):
"""Sets attr of current selection to value"""
if selection is None:
selection = self.grid.selection
if not selection:
# Add current cell to selection so that it gets changed
selection.cells.append(self.grid.actions.cursor[:2])
attrs = {attr: value}
table = self.grid.current_table
# Change model
self._set_cell_attr(selection, table, attrs) | python | def set_attr(self, attr, value, selection=None):
"""Sets attr of current selection to value"""
if selection is None:
selection = self.grid.selection
if not selection:
# Add current cell to selection so that it gets changed
selection.cells.append(self.grid.actions.cursor[:2])
attrs = {attr: value}
table = self.grid.current_table
# Change model
self._set_cell_attr(selection, table, attrs) | [
"def",
"set_attr",
"(",
"self",
",",
"attr",
",",
"value",
",",
"selection",
"=",
"None",
")",
":",
"if",
"selection",
"is",
"None",
":",
"selection",
"=",
"self",
".",
"grid",
".",
"selection",
"if",
"not",
"selection",
":",
"# Add current cell to selecti... | Sets attr of current selection to value | [
"Sets",
"attr",
"of",
"current",
"selection",
"to",
"value"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_grid_cell_actions.py#L209-L224 | train | 231,168 |
manns/pyspread | pyspread/src/actions/_grid_cell_actions.py | CellActions.set_border_attr | def set_border_attr(self, attr, value, borders):
"""Sets border attribute by adjusting selection to borders
Parameters
----------
attr: String in ["borderwidth", "bordercolor"]
\tBorder attribute that shall be changed
value: wx.Colour or Integer
\tAttribute value dependent on attribute type
borders: Iterable over "top", "bottom", "left", "right", "inner"
\tSpecifies to which borders of the selection the attr is applied
"""
selection = self.grid.selection
if not selection:
selection.cells.append(self.grid.actions.cursor[:2])
# determine selection for core cells and selection for border cells
# Then apply according to inner and outer
# A cell is inner iif it is not at the edge of the selection bbox
if "inner" in borders:
if "top" in borders:
adj_selection = selection + (-1, 0)
self.set_attr(attr + "_bottom", value, adj_selection)
if "bottom" in borders:
self.set_attr(attr + "_bottom", value)
if "left" in borders:
adj_selection = selection + (0, -1)
self.set_attr(attr + "_right", value, adj_selection)
if "right" in borders:
self.set_attr(attr + "_right", value)
else:
# Adjust selection so that only bounding box edge is in selection
bbox_tl, bbox_lr = selection.get_bbox()
if "top" in borders:
adj_selection = Selection([bbox_tl],
[(bbox_tl[0], bbox_lr[1])],
[], [], []) + (-1, 0)
self.set_attr(attr + "_bottom", value, adj_selection)
if "bottom" in borders:
adj_selection = Selection([(bbox_lr[0], bbox_tl[1])],
[bbox_lr], [], [], [])
self.set_attr(attr + "_bottom", value, adj_selection)
if "left" in borders:
adj_selection = Selection([bbox_tl],
[(bbox_lr[0], bbox_tl[1])],
[], [], []) + (0, -1)
self.set_attr(attr + "_right", value, adj_selection)
if "right" in borders:
adj_selection = Selection([(bbox_tl[0], bbox_lr[1])],
[bbox_lr], [], [], [])
self.set_attr(attr + "_right", value, adj_selection) | python | def set_border_attr(self, attr, value, borders):
"""Sets border attribute by adjusting selection to borders
Parameters
----------
attr: String in ["borderwidth", "bordercolor"]
\tBorder attribute that shall be changed
value: wx.Colour or Integer
\tAttribute value dependent on attribute type
borders: Iterable over "top", "bottom", "left", "right", "inner"
\tSpecifies to which borders of the selection the attr is applied
"""
selection = self.grid.selection
if not selection:
selection.cells.append(self.grid.actions.cursor[:2])
# determine selection for core cells and selection for border cells
# Then apply according to inner and outer
# A cell is inner iif it is not at the edge of the selection bbox
if "inner" in borders:
if "top" in borders:
adj_selection = selection + (-1, 0)
self.set_attr(attr + "_bottom", value, adj_selection)
if "bottom" in borders:
self.set_attr(attr + "_bottom", value)
if "left" in borders:
adj_selection = selection + (0, -1)
self.set_attr(attr + "_right", value, adj_selection)
if "right" in borders:
self.set_attr(attr + "_right", value)
else:
# Adjust selection so that only bounding box edge is in selection
bbox_tl, bbox_lr = selection.get_bbox()
if "top" in borders:
adj_selection = Selection([bbox_tl],
[(bbox_tl[0], bbox_lr[1])],
[], [], []) + (-1, 0)
self.set_attr(attr + "_bottom", value, adj_selection)
if "bottom" in borders:
adj_selection = Selection([(bbox_lr[0], bbox_tl[1])],
[bbox_lr], [], [], [])
self.set_attr(attr + "_bottom", value, adj_selection)
if "left" in borders:
adj_selection = Selection([bbox_tl],
[(bbox_lr[0], bbox_tl[1])],
[], [], []) + (0, -1)
self.set_attr(attr + "_right", value, adj_selection)
if "right" in borders:
adj_selection = Selection([(bbox_tl[0], bbox_lr[1])],
[bbox_lr], [], [], [])
self.set_attr(attr + "_right", value, adj_selection) | [
"def",
"set_border_attr",
"(",
"self",
",",
"attr",
",",
"value",
",",
"borders",
")",
":",
"selection",
"=",
"self",
".",
"grid",
".",
"selection",
"if",
"not",
"selection",
":",
"selection",
".",
"cells",
".",
"append",
"(",
"self",
".",
"grid",
".",... | Sets border attribute by adjusting selection to borders
Parameters
----------
attr: String in ["borderwidth", "bordercolor"]
\tBorder attribute that shall be changed
value: wx.Colour or Integer
\tAttribute value dependent on attribute type
borders: Iterable over "top", "bottom", "left", "right", "inner"
\tSpecifies to which borders of the selection the attr is applied | [
"Sets",
"border",
"attribute",
"by",
"adjusting",
"selection",
"to",
"borders"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_grid_cell_actions.py#L226-L286 | train | 231,169 |
manns/pyspread | pyspread/src/actions/_grid_cell_actions.py | CellActions.toggle_attr | def toggle_attr(self, attr):
"""Toggles an attribute attr for current selection"""
selection = self.grid.selection
# Selection or single cell access?
if selection:
value = self.get_new_selection_attr_state(selection, attr)
else:
value = self.get_new_cell_attr_state(self.grid.actions.cursor,
attr)
# Set the toggled value
self.set_attr(attr, value) | python | def toggle_attr(self, attr):
"""Toggles an attribute attr for current selection"""
selection = self.grid.selection
# Selection or single cell access?
if selection:
value = self.get_new_selection_attr_state(selection, attr)
else:
value = self.get_new_cell_attr_state(self.grid.actions.cursor,
attr)
# Set the toggled value
self.set_attr(attr, value) | [
"def",
"toggle_attr",
"(",
"self",
",",
"attr",
")",
":",
"selection",
"=",
"self",
".",
"grid",
".",
"selection",
"# Selection or single cell access?",
"if",
"selection",
":",
"value",
"=",
"self",
".",
"get_new_selection_attr_state",
"(",
"selection",
",",
"at... | Toggles an attribute attr for current selection | [
"Toggles",
"an",
"attribute",
"attr",
"for",
"current",
"selection"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_grid_cell_actions.py#L288-L304 | train | 231,170 |
manns/pyspread | pyspread/src/actions/_grid_cell_actions.py | CellActions.change_frozen_attr | def change_frozen_attr(self):
"""Changes frozen state of cell if there is no selection"""
# Selections are not supported
if self.grid.selection:
statustext = _("Freezing selections is not supported.")
post_command_event(self.main_window, self.StatusBarMsg,
text=statustext)
cursor = self.grid.actions.cursor
frozen = self.grid.code_array.cell_attributes[cursor]["frozen"]
if frozen:
# We have an frozen cell that has to be unfrozen
# Delete frozen cache content
self.grid.code_array.frozen_cache.pop(repr(cursor))
else:
# We have an non-frozen cell that has to be frozen
# Add frozen cache content
res_obj = self.grid.code_array[cursor]
self.grid.code_array.frozen_cache[repr(cursor)] = res_obj
# Set the new frozen state / code
selection = Selection([], [], [], [], [cursor[:2]])
self.set_attr("frozen", not frozen, selection=selection) | python | def change_frozen_attr(self):
"""Changes frozen state of cell if there is no selection"""
# Selections are not supported
if self.grid.selection:
statustext = _("Freezing selections is not supported.")
post_command_event(self.main_window, self.StatusBarMsg,
text=statustext)
cursor = self.grid.actions.cursor
frozen = self.grid.code_array.cell_attributes[cursor]["frozen"]
if frozen:
# We have an frozen cell that has to be unfrozen
# Delete frozen cache content
self.grid.code_array.frozen_cache.pop(repr(cursor))
else:
# We have an non-frozen cell that has to be frozen
# Add frozen cache content
res_obj = self.grid.code_array[cursor]
self.grid.code_array.frozen_cache[repr(cursor)] = res_obj
# Set the new frozen state / code
selection = Selection([], [], [], [], [cursor[:2]])
self.set_attr("frozen", not frozen, selection=selection) | [
"def",
"change_frozen_attr",
"(",
"self",
")",
":",
"# Selections are not supported",
"if",
"self",
".",
"grid",
".",
"selection",
":",
"statustext",
"=",
"_",
"(",
"\"Freezing selections is not supported.\"",
")",
"post_command_event",
"(",
"self",
".",
"main_window"... | Changes frozen state of cell if there is no selection | [
"Changes",
"frozen",
"state",
"of",
"cell",
"if",
"there",
"is",
"no",
"selection"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_grid_cell_actions.py#L308-L337 | train | 231,171 |
manns/pyspread | pyspread/src/actions/_grid_cell_actions.py | CellActions.unmerge | def unmerge(self, unmerge_area, tab):
"""Unmerges all cells in unmerge_area"""
top, left, bottom, right = unmerge_area
selection = Selection([(top, left)], [(bottom, right)], [], [], [])
attr = {"merge_area": None, "locked": False}
self._set_cell_attr(selection, tab, attr) | python | def unmerge(self, unmerge_area, tab):
"""Unmerges all cells in unmerge_area"""
top, left, bottom, right = unmerge_area
selection = Selection([(top, left)], [(bottom, right)], [], [], [])
attr = {"merge_area": None, "locked": False}
self._set_cell_attr(selection, tab, attr) | [
"def",
"unmerge",
"(",
"self",
",",
"unmerge_area",
",",
"tab",
")",
":",
"top",
",",
"left",
",",
"bottom",
",",
"right",
"=",
"unmerge_area",
"selection",
"=",
"Selection",
"(",
"[",
"(",
"top",
",",
"left",
")",
"]",
",",
"[",
"(",
"bottom",
","... | Unmerges all cells in unmerge_area | [
"Unmerges",
"all",
"cells",
"in",
"unmerge_area"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_grid_cell_actions.py#L339-L346 | train | 231,172 |
manns/pyspread | pyspread/src/actions/_grid_cell_actions.py | CellActions.merge | def merge(self, merge_area, tab):
"""Merges top left cell with all cells until bottom_right"""
top, left, bottom, right = merge_area
cursor = self.grid.actions.cursor
top_left_code = self.code_array((top, left, cursor[2]))
selection = Selection([(top, left)], [(bottom, right)], [], [], [])
# Check if the merge area overlaps another merge area
error_msg = _("Overlapping merge area at {} prevents merge.")
for row in xrange(top, bottom + 1):
for col in xrange(left, right + 1):
key = row, col, tab
if self.code_array.cell_attributes[key]["merge_area"]:
post_command_event(self.main_window, self.StatusBarMsg,
text=error_msg.format(str(key)))
return
self.delete_selection(selection)
self.set_code((top, left, cursor[2]), top_left_code)
attr = {"merge_area": merge_area, "locked": True}
self._set_cell_attr(selection, tab, attr)
tl_selection = Selection([], [], [], [], [(top, left)])
attr = {"locked": False}
self._set_cell_attr(tl_selection, tab, attr) | python | def merge(self, merge_area, tab):
"""Merges top left cell with all cells until bottom_right"""
top, left, bottom, right = merge_area
cursor = self.grid.actions.cursor
top_left_code = self.code_array((top, left, cursor[2]))
selection = Selection([(top, left)], [(bottom, right)], [], [], [])
# Check if the merge area overlaps another merge area
error_msg = _("Overlapping merge area at {} prevents merge.")
for row in xrange(top, bottom + 1):
for col in xrange(left, right + 1):
key = row, col, tab
if self.code_array.cell_attributes[key]["merge_area"]:
post_command_event(self.main_window, self.StatusBarMsg,
text=error_msg.format(str(key)))
return
self.delete_selection(selection)
self.set_code((top, left, cursor[2]), top_left_code)
attr = {"merge_area": merge_area, "locked": True}
self._set_cell_attr(selection, tab, attr)
tl_selection = Selection([], [], [], [], [(top, left)])
attr = {"locked": False}
self._set_cell_attr(tl_selection, tab, attr) | [
"def",
"merge",
"(",
"self",
",",
"merge_area",
",",
"tab",
")",
":",
"top",
",",
"left",
",",
"bottom",
",",
"right",
"=",
"merge_area",
"cursor",
"=",
"self",
".",
"grid",
".",
"actions",
".",
"cursor",
"top_left_code",
"=",
"self",
".",
"code_array"... | Merges top left cell with all cells until bottom_right | [
"Merges",
"top",
"left",
"cell",
"with",
"all",
"cells",
"until",
"bottom_right"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_grid_cell_actions.py#L348-L380 | train | 231,173 |
manns/pyspread | pyspread/src/actions/_grid_cell_actions.py | CellActions.merge_selected_cells | def merge_selected_cells(self, selection):
"""Merges or unmerges cells that are in the selection bounding box
Parameters
----------
selection: Selection object
\tSelection for which attr toggle shall be returned
"""
tab = self.grid.current_table
# Get the selection bounding box
bbox = selection.get_bbox()
if bbox is None:
row, col, tab = self.grid.actions.cursor
(bb_top, bb_left), (bb_bottom, bb_right) = (row, col), (row, col)
else:
(bb_top, bb_left), (bb_bottom, bb_right) = bbox
merge_area = bb_top, bb_left, bb_bottom, bb_right
# Check if top-left cell is already merged
cell_attributes = self.grid.code_array.cell_attributes
tl_merge_area = cell_attributes[(bb_top, bb_left, tab)]["merge_area"]
if tl_merge_area is not None and tl_merge_area[:2] == merge_area[:2]:
self.unmerge(tl_merge_area, tab)
else:
self.merge(merge_area, tab) | python | def merge_selected_cells(self, selection):
"""Merges or unmerges cells that are in the selection bounding box
Parameters
----------
selection: Selection object
\tSelection for which attr toggle shall be returned
"""
tab = self.grid.current_table
# Get the selection bounding box
bbox = selection.get_bbox()
if bbox is None:
row, col, tab = self.grid.actions.cursor
(bb_top, bb_left), (bb_bottom, bb_right) = (row, col), (row, col)
else:
(bb_top, bb_left), (bb_bottom, bb_right) = bbox
merge_area = bb_top, bb_left, bb_bottom, bb_right
# Check if top-left cell is already merged
cell_attributes = self.grid.code_array.cell_attributes
tl_merge_area = cell_attributes[(bb_top, bb_left, tab)]["merge_area"]
if tl_merge_area is not None and tl_merge_area[:2] == merge_area[:2]:
self.unmerge(tl_merge_area, tab)
else:
self.merge(merge_area, tab) | [
"def",
"merge_selected_cells",
"(",
"self",
",",
"selection",
")",
":",
"tab",
"=",
"self",
".",
"grid",
".",
"current_table",
"# Get the selection bounding box",
"bbox",
"=",
"selection",
".",
"get_bbox",
"(",
")",
"if",
"bbox",
"is",
"None",
":",
"row",
",... | Merges or unmerges cells that are in the selection bounding box
Parameters
----------
selection: Selection object
\tSelection for which attr toggle shall be returned | [
"Merges",
"or",
"unmerges",
"cells",
"that",
"are",
"in",
"the",
"selection",
"bounding",
"box"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_grid_cell_actions.py#L382-L410 | train | 231,174 |
manns/pyspread | pyspread/src/actions/_grid_cell_actions.py | CellActions.get_new_cell_attr_state | def get_new_cell_attr_state(self, key, attr_key):
"""Returns new attr cell state for toggles
Parameters
----------
key: 3-Tuple
\tCell for which attr toggle shall be returned
attr_key: Hashable
\tAttribute key
"""
cell_attributes = self.grid.code_array.cell_attributes
attr_values = self.attr_toggle_values[attr_key]
# Map attr_value to next attr_value
attr_map = dict(zip(attr_values, attr_values[1:] + attr_values[:1]))
# Return next value from attr_toggle_values value list
return attr_map[cell_attributes[key][attr_key]] | python | def get_new_cell_attr_state(self, key, attr_key):
"""Returns new attr cell state for toggles
Parameters
----------
key: 3-Tuple
\tCell for which attr toggle shall be returned
attr_key: Hashable
\tAttribute key
"""
cell_attributes = self.grid.code_array.cell_attributes
attr_values = self.attr_toggle_values[attr_key]
# Map attr_value to next attr_value
attr_map = dict(zip(attr_values, attr_values[1:] + attr_values[:1]))
# Return next value from attr_toggle_values value list
return attr_map[cell_attributes[key][attr_key]] | [
"def",
"get_new_cell_attr_state",
"(",
"self",
",",
"key",
",",
"attr_key",
")",
":",
"cell_attributes",
"=",
"self",
".",
"grid",
".",
"code_array",
".",
"cell_attributes",
"attr_values",
"=",
"self",
".",
"attr_toggle_values",
"[",
"attr_key",
"]",
"# Map attr... | Returns new attr cell state for toggles
Parameters
----------
key: 3-Tuple
\tCell for which attr toggle shall be returned
attr_key: Hashable
\tAttribute key | [
"Returns",
"new",
"attr",
"cell",
"state",
"for",
"toggles"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_grid_cell_actions.py#L425-L445 | train | 231,175 |
manns/pyspread | pyspread/src/actions/_grid_cell_actions.py | CellActions.get_new_selection_attr_state | def get_new_selection_attr_state(self, selection, attr_key):
"""Toggles new attr selection state and returns it
Parameters
----------
selection: Selection object
\tSelection for which attr toggle shall be returned
attr_key: Hashable
\tAttribute key
"""
cell_attributes = self.grid.code_array.cell_attributes
attr_values = self.attr_toggle_values[attr_key]
# Map attr_value to next attr_value
attr_map = dict(zip(attr_values, attr_values[1:] + attr_values[:1]))
selection_attrs = \
(attr for attr in cell_attributes if attr[0] == selection)
attrs = {}
for selection_attr in selection_attrs:
attrs.update(selection_attr[2])
if attr_key in attrs:
return attr_map[attrs[attr_key]]
else:
# Default next value
return self.attr_toggle_values[attr_key][1] | python | def get_new_selection_attr_state(self, selection, attr_key):
"""Toggles new attr selection state and returns it
Parameters
----------
selection: Selection object
\tSelection for which attr toggle shall be returned
attr_key: Hashable
\tAttribute key
"""
cell_attributes = self.grid.code_array.cell_attributes
attr_values = self.attr_toggle_values[attr_key]
# Map attr_value to next attr_value
attr_map = dict(zip(attr_values, attr_values[1:] + attr_values[:1]))
selection_attrs = \
(attr for attr in cell_attributes if attr[0] == selection)
attrs = {}
for selection_attr in selection_attrs:
attrs.update(selection_attr[2])
if attr_key in attrs:
return attr_map[attrs[attr_key]]
else:
# Default next value
return self.attr_toggle_values[attr_key][1] | [
"def",
"get_new_selection_attr_state",
"(",
"self",
",",
"selection",
",",
"attr_key",
")",
":",
"cell_attributes",
"=",
"self",
".",
"grid",
".",
"code_array",
".",
"cell_attributes",
"attr_values",
"=",
"self",
".",
"attr_toggle_values",
"[",
"attr_key",
"]",
... | Toggles new attr selection state and returns it
Parameters
----------
selection: Selection object
\tSelection for which attr toggle shall be returned
attr_key: Hashable
\tAttribute key | [
"Toggles",
"new",
"attr",
"selection",
"state",
"and",
"returns",
"it"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_grid_cell_actions.py#L447-L477 | train | 231,176 |
manns/pyspread | pyspread/src/actions/_grid_cell_actions.py | CellActions.refresh_frozen_cell | def refresh_frozen_cell(self, key):
"""Refreshes a frozen cell"""
code = self.grid.code_array(key)
result = self.grid.code_array._eval_cell(key, code)
self.grid.code_array.frozen_cache[repr(key)] = result | python | def refresh_frozen_cell(self, key):
"""Refreshes a frozen cell"""
code = self.grid.code_array(key)
result = self.grid.code_array._eval_cell(key, code)
self.grid.code_array.frozen_cache[repr(key)] = result | [
"def",
"refresh_frozen_cell",
"(",
"self",
",",
"key",
")",
":",
"code",
"=",
"self",
".",
"grid",
".",
"code_array",
"(",
"key",
")",
"result",
"=",
"self",
".",
"grid",
".",
"code_array",
".",
"_eval_cell",
"(",
"key",
",",
"code",
")",
"self",
"."... | Refreshes a frozen cell | [
"Refreshes",
"a",
"frozen",
"cell"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_grid_cell_actions.py#L479-L484 | train | 231,177 |
manns/pyspread | pyspread/src/actions/_grid_cell_actions.py | CellActions.refresh_selected_frozen_cells | def refresh_selected_frozen_cells(self, selection=None):
"""Refreshes content of frozen cells that are currently selected
If there is no selection, the cell at the cursor is updated.
Parameters
----------
selection: Selection, defaults to None
\tIf not None then use this selection instead of the grid selection
"""
if selection is None:
selection = self.grid.selection
# Add cursor to empty selection
if not selection:
selection.cells.append(self.grid.actions.cursor[:2])
cell_attributes = self.grid.code_array.cell_attributes
refreshed_keys = []
for attr_selection, tab, attr_dict in cell_attributes:
if tab == self.grid.actions.cursor[2] and \
"frozen" in attr_dict and attr_dict["frozen"]:
# Only single cells are allowed for freezing
skey = attr_selection.cells[0]
if skey in selection:
key = tuple(list(skey) + [tab])
if key not in refreshed_keys and \
cell_attributes[key]["frozen"]:
self.refresh_frozen_cell(key)
refreshed_keys.append(key)
cell_attributes._attr_cache.clear()
cell_attributes._table_cache.clear() | python | def refresh_selected_frozen_cells(self, selection=None):
"""Refreshes content of frozen cells that are currently selected
If there is no selection, the cell at the cursor is updated.
Parameters
----------
selection: Selection, defaults to None
\tIf not None then use this selection instead of the grid selection
"""
if selection is None:
selection = self.grid.selection
# Add cursor to empty selection
if not selection:
selection.cells.append(self.grid.actions.cursor[:2])
cell_attributes = self.grid.code_array.cell_attributes
refreshed_keys = []
for attr_selection, tab, attr_dict in cell_attributes:
if tab == self.grid.actions.cursor[2] and \
"frozen" in attr_dict and attr_dict["frozen"]:
# Only single cells are allowed for freezing
skey = attr_selection.cells[0]
if skey in selection:
key = tuple(list(skey) + [tab])
if key not in refreshed_keys and \
cell_attributes[key]["frozen"]:
self.refresh_frozen_cell(key)
refreshed_keys.append(key)
cell_attributes._attr_cache.clear()
cell_attributes._table_cache.clear() | [
"def",
"refresh_selected_frozen_cells",
"(",
"self",
",",
"selection",
"=",
"None",
")",
":",
"if",
"selection",
"is",
"None",
":",
"selection",
"=",
"self",
".",
"grid",
".",
"selection",
"# Add cursor to empty selection",
"if",
"not",
"selection",
":",
"select... | Refreshes content of frozen cells that are currently selected
If there is no selection, the cell at the cursor is updated.
Parameters
----------
selection: Selection, defaults to None
\tIf not None then use this selection instead of the grid selection | [
"Refreshes",
"content",
"of",
"frozen",
"cells",
"that",
"are",
"currently",
"selected"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_grid_cell_actions.py#L486-L523 | train | 231,178 |
manns/pyspread | pyspread/src/actions/_main_window_actions.py | ExchangeActions._import_csv | def _import_csv(self, path):
"""CSV import workflow"""
# If path is not set, do nothing
if not path:
return
# Get csv info
try:
dialect, has_header, digest_types, encoding = \
self.main_window.interfaces.get_csv_import_info(path)
except IOError:
msg = _("Error opening file {filepath}.").format(filepath=path)
post_command_event(self.main_window, self.StatusBarMsg, text=msg)
return
except TypeError:
return # Import is aborted or empty
return CsvInterface(self.main_window,
path, dialect, digest_types, has_header, encoding) | python | def _import_csv(self, path):
"""CSV import workflow"""
# If path is not set, do nothing
if not path:
return
# Get csv info
try:
dialect, has_header, digest_types, encoding = \
self.main_window.interfaces.get_csv_import_info(path)
except IOError:
msg = _("Error opening file {filepath}.").format(filepath=path)
post_command_event(self.main_window, self.StatusBarMsg, text=msg)
return
except TypeError:
return # Import is aborted or empty
return CsvInterface(self.main_window,
path, dialect, digest_types, has_header, encoding) | [
"def",
"_import_csv",
"(",
"self",
",",
"path",
")",
":",
"# If path is not set, do nothing",
"if",
"not",
"path",
":",
"return",
"# Get csv info",
"try",
":",
"dialect",
",",
"has_header",
",",
"digest_types",
",",
"encoding",
"=",
"self",
".",
"main_window",
... | CSV import workflow | [
"CSV",
"import",
"workflow"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_main_window_actions.py#L88-L110 | train | 231,179 |
manns/pyspread | pyspread/src/actions/_main_window_actions.py | ExchangeActions.import_file | def import_file(self, filepath, filterindex):
"""Imports external file
Parameters
----------
filepath: String
\tPath of import file
filterindex: Integer
\tIndex for type of file, 0: csv, 1: tab-delimited text file
"""
# Mark content as changed
post_command_event(self.main_window, self.ContentChangedMsg)
if filterindex == 0:
# CSV import option choice
return self._import_csv(filepath)
elif filterindex == 1:
# TXT import option choice
return self._import_txt(filepath)
else:
msg = _("Unknown import choice {choice}.")
msg = msg.format(choice=filterindex)
short_msg = _('Error reading CSV file')
self.main_window.interfaces.display_warning(msg, short_msg) | python | def import_file(self, filepath, filterindex):
"""Imports external file
Parameters
----------
filepath: String
\tPath of import file
filterindex: Integer
\tIndex for type of file, 0: csv, 1: tab-delimited text file
"""
# Mark content as changed
post_command_event(self.main_window, self.ContentChangedMsg)
if filterindex == 0:
# CSV import option choice
return self._import_csv(filepath)
elif filterindex == 1:
# TXT import option choice
return self._import_txt(filepath)
else:
msg = _("Unknown import choice {choice}.")
msg = msg.format(choice=filterindex)
short_msg = _('Error reading CSV file')
self.main_window.interfaces.display_warning(msg, short_msg) | [
"def",
"import_file",
"(",
"self",
",",
"filepath",
",",
"filterindex",
")",
":",
"# Mark content as changed",
"post_command_event",
"(",
"self",
".",
"main_window",
",",
"self",
".",
"ContentChangedMsg",
")",
"if",
"filterindex",
"==",
"0",
":",
"# CSV import opt... | Imports external file
Parameters
----------
filepath: String
\tPath of import file
filterindex: Integer
\tIndex for type of file, 0: csv, 1: tab-delimited text file | [
"Imports",
"external",
"file"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_main_window_actions.py#L117-L144 | train | 231,180 |
manns/pyspread | pyspread/src/actions/_main_window_actions.py | ExchangeActions._export_csv | def _export_csv(self, filepath, data, preview_data):
"""CSV export of code_array results
Parameters
----------
filepath: String
\tPath of export file
data: Object
\tCode array result object slice, i. e. one object or iterable of
\tsuch objects
"""
# Get csv info
csv_info = \
self.main_window.interfaces.get_csv_export_info(preview_data)
if csv_info is None:
return
try:
dialect, digest_types, has_header = csv_info
except TypeError:
return
# Export CSV file
csv_interface = CsvInterface(self.main_window, filepath, dialect,
digest_types, has_header)
try:
csv_interface.write(data)
except IOError, err:
msg = _("The file {filepath} could not be fully written\n \n"
"Error message:\n{msg}")
msg = msg.format(filepath=filepath, msg=err)
short_msg = _('Error writing CSV file')
self.main_window.interfaces.display_warning(msg, short_msg) | python | def _export_csv(self, filepath, data, preview_data):
"""CSV export of code_array results
Parameters
----------
filepath: String
\tPath of export file
data: Object
\tCode array result object slice, i. e. one object or iterable of
\tsuch objects
"""
# Get csv info
csv_info = \
self.main_window.interfaces.get_csv_export_info(preview_data)
if csv_info is None:
return
try:
dialect, digest_types, has_header = csv_info
except TypeError:
return
# Export CSV file
csv_interface = CsvInterface(self.main_window, filepath, dialect,
digest_types, has_header)
try:
csv_interface.write(data)
except IOError, err:
msg = _("The file {filepath} could not be fully written\n \n"
"Error message:\n{msg}")
msg = msg.format(filepath=filepath, msg=err)
short_msg = _('Error writing CSV file')
self.main_window.interfaces.display_warning(msg, short_msg) | [
"def",
"_export_csv",
"(",
"self",
",",
"filepath",
",",
"data",
",",
"preview_data",
")",
":",
"# Get csv info",
"csv_info",
"=",
"self",
".",
"main_window",
".",
"interfaces",
".",
"get_csv_export_info",
"(",
"preview_data",
")",
"if",
"csv_info",
"is",
"Non... | CSV export of code_array results
Parameters
----------
filepath: String
\tPath of export file
data: Object
\tCode array result object slice, i. e. one object or iterable of
\tsuch objects | [
"CSV",
"export",
"of",
"code_array",
"results"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_main_window_actions.py#L146-L185 | train | 231,181 |
manns/pyspread | pyspread/src/actions/_main_window_actions.py | ExchangeActions._export_figure | def _export_figure(self, filepath, data, format):
"""Export of single cell that contains a matplotlib figure
Parameters
----------
filepath: String
\tPath of export file
data: Matplotlib Figure
\tMatplotlib figure that is eported
format: String in ["png", "pdf", "ps", "eps", "svg"]
"""
formats = ["svg", "eps", "ps", "pdf", "png"]
assert format in formats
data = fig2x(data, format)
try:
outfile = open(filepath, "wb")
outfile.write(data)
except IOError, err:
msg = _("The file {filepath} could not be fully written\n \n"
"Error message:\n{msg}")
msg = msg.format(filepath=filepath, msg=err)
short_msg = _('Error writing SVG file')
self.main_window.interfaces.display_warning(msg, short_msg)
finally:
outfile.close() | python | def _export_figure(self, filepath, data, format):
"""Export of single cell that contains a matplotlib figure
Parameters
----------
filepath: String
\tPath of export file
data: Matplotlib Figure
\tMatplotlib figure that is eported
format: String in ["png", "pdf", "ps", "eps", "svg"]
"""
formats = ["svg", "eps", "ps", "pdf", "png"]
assert format in formats
data = fig2x(data, format)
try:
outfile = open(filepath, "wb")
outfile.write(data)
except IOError, err:
msg = _("The file {filepath} could not be fully written\n \n"
"Error message:\n{msg}")
msg = msg.format(filepath=filepath, msg=err)
short_msg = _('Error writing SVG file')
self.main_window.interfaces.display_warning(msg, short_msg)
finally:
outfile.close() | [
"def",
"_export_figure",
"(",
"self",
",",
"filepath",
",",
"data",
",",
"format",
")",
":",
"formats",
"=",
"[",
"\"svg\"",
",",
"\"eps\"",
",",
"\"ps\"",
",",
"\"pdf\"",
",",
"\"png\"",
"]",
"assert",
"format",
"in",
"formats",
"data",
"=",
"fig2x",
... | Export of single cell that contains a matplotlib figure
Parameters
----------
filepath: String
\tPath of export file
data: Matplotlib Figure
\tMatplotlib figure that is eported
format: String in ["png", "pdf", "ps", "eps", "svg"] | [
"Export",
"of",
"single",
"cell",
"that",
"contains",
"a",
"matplotlib",
"figure"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_main_window_actions.py#L187-L217 | train | 231,182 |
manns/pyspread | pyspread/src/actions/_main_window_actions.py | ExchangeActions.export_file | def export_file(self, filepath, __filter, data, preview_data=None):
"""Export data for other applications
Parameters
----------
filepath: String
\tPath of export file
__filter: String
\tImport filter
data: Object
\tCode array result object slice, i. e. one object or iterable of
\tsuch objects
"""
if __filter.startswith("cell_"):
self._export_figure(filepath, data, __filter[5:])
elif __filter == "csv":
self._export_csv(filepath, data, preview_data=preview_data)
elif __filter in ["pdf", "svg"]:
self.export_cairo(filepath, __filter) | python | def export_file(self, filepath, __filter, data, preview_data=None):
"""Export data for other applications
Parameters
----------
filepath: String
\tPath of export file
__filter: String
\tImport filter
data: Object
\tCode array result object slice, i. e. one object or iterable of
\tsuch objects
"""
if __filter.startswith("cell_"):
self._export_figure(filepath, data, __filter[5:])
elif __filter == "csv":
self._export_csv(filepath, data, preview_data=preview_data)
elif __filter in ["pdf", "svg"]:
self.export_cairo(filepath, __filter) | [
"def",
"export_file",
"(",
"self",
",",
"filepath",
",",
"__filter",
",",
"data",
",",
"preview_data",
"=",
"None",
")",
":",
"if",
"__filter",
".",
"startswith",
"(",
"\"cell_\"",
")",
":",
"self",
".",
"_export_figure",
"(",
"filepath",
",",
"data",
",... | Export data for other applications
Parameters
----------
filepath: String
\tPath of export file
__filter: String
\tImport filter
data: Object
\tCode array result object slice, i. e. one object or iterable of
\tsuch objects | [
"Export",
"data",
"for",
"other",
"applications"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_main_window_actions.py#L219-L241 | train | 231,183 |
manns/pyspread | pyspread/src/actions/_main_window_actions.py | ExchangeActions.get_print_rect | def get_print_rect(self, grid_rect):
"""Returns wx.Rect that is correctly positioned on the print canvas"""
grid = self.grid
rect_x = grid_rect.x - \
grid.GetScrollPos(wx.HORIZONTAL) * grid.GetScrollLineX()
rect_y = grid_rect.y - \
grid.GetScrollPos(wx.VERTICAL) * grid.GetScrollLineY()
return wx.Rect(rect_x, rect_y, grid_rect.width, grid_rect.height) | python | def get_print_rect(self, grid_rect):
"""Returns wx.Rect that is correctly positioned on the print canvas"""
grid = self.grid
rect_x = grid_rect.x - \
grid.GetScrollPos(wx.HORIZONTAL) * grid.GetScrollLineX()
rect_y = grid_rect.y - \
grid.GetScrollPos(wx.VERTICAL) * grid.GetScrollLineY()
return wx.Rect(rect_x, rect_y, grid_rect.width, grid_rect.height) | [
"def",
"get_print_rect",
"(",
"self",
",",
"grid_rect",
")",
":",
"grid",
"=",
"self",
".",
"grid",
"rect_x",
"=",
"grid_rect",
".",
"x",
"-",
"grid",
".",
"GetScrollPos",
"(",
"wx",
".",
"HORIZONTAL",
")",
"*",
"grid",
".",
"GetScrollLineX",
"(",
")",... | Returns wx.Rect that is correctly positioned on the print canvas | [
"Returns",
"wx",
".",
"Rect",
"that",
"is",
"correctly",
"positioned",
"on",
"the",
"print",
"canvas"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_main_window_actions.py#L243-L253 | train | 231,184 |
manns/pyspread | pyspread/src/actions/_main_window_actions.py | ExchangeActions.export_cairo | def export_cairo(self, filepath, filetype):
"""Exports grid to the PDF file filepath
Parameters
----------
filepath: String
\tPath of file to export
filetype in ["pdf", "svg"]
\tType of file to export
"""
if cairo is None:
return
export_info = \
self.main_window.interfaces.get_cairo_export_info(filetype)
if export_info is None:
# Dialog has been canceled
return
top_row = max(0, export_info["top_row"])
bottom_row = min(self.grid.code_array.shape[0] - 1,
export_info["bottom_row"])
left_col = max(0, export_info["left_col"])
right_col = min(self.grid.code_array.shape[1] - 1,
export_info["right_col"])
first_tab = max(0, export_info["first_tab"])
last_tab = min(self.grid.code_array.shape[2] - 1,
export_info["last_tab"])
width = export_info["paper_width"]
height = export_info["paper_height"]
orientation = export_info["orientation"]
if orientation == "landscape":
width, height = height, width
if filetype == "pdf":
surface = cairo.PDFSurface(filepath, width, height)
elif filetype == "svg":
surface = cairo.SVGSurface(filepath, width, height)
else:
msg = "Export filetype {filtype} not supported.".format(
filetype=filetype)
raise ValueError(msg)
context = cairo.Context(surface)
grid_cairo_renderer = GridCairoRenderer(
context,
self.code_array,
(top_row, bottom_row + 1),
(left_col, right_col + 1),
(first_tab, last_tab + 1),
width,
height,
orientation,
view_frozen=self.grid._view_frozen,
)
grid_cairo_renderer.draw()
# Finish is required for matplotlib figures
surface.finish() | python | def export_cairo(self, filepath, filetype):
"""Exports grid to the PDF file filepath
Parameters
----------
filepath: String
\tPath of file to export
filetype in ["pdf", "svg"]
\tType of file to export
"""
if cairo is None:
return
export_info = \
self.main_window.interfaces.get_cairo_export_info(filetype)
if export_info is None:
# Dialog has been canceled
return
top_row = max(0, export_info["top_row"])
bottom_row = min(self.grid.code_array.shape[0] - 1,
export_info["bottom_row"])
left_col = max(0, export_info["left_col"])
right_col = min(self.grid.code_array.shape[1] - 1,
export_info["right_col"])
first_tab = max(0, export_info["first_tab"])
last_tab = min(self.grid.code_array.shape[2] - 1,
export_info["last_tab"])
width = export_info["paper_width"]
height = export_info["paper_height"]
orientation = export_info["orientation"]
if orientation == "landscape":
width, height = height, width
if filetype == "pdf":
surface = cairo.PDFSurface(filepath, width, height)
elif filetype == "svg":
surface = cairo.SVGSurface(filepath, width, height)
else:
msg = "Export filetype {filtype} not supported.".format(
filetype=filetype)
raise ValueError(msg)
context = cairo.Context(surface)
grid_cairo_renderer = GridCairoRenderer(
context,
self.code_array,
(top_row, bottom_row + 1),
(left_col, right_col + 1),
(first_tab, last_tab + 1),
width,
height,
orientation,
view_frozen=self.grid._view_frozen,
)
grid_cairo_renderer.draw()
# Finish is required for matplotlib figures
surface.finish() | [
"def",
"export_cairo",
"(",
"self",
",",
"filepath",
",",
"filetype",
")",
":",
"if",
"cairo",
"is",
"None",
":",
"return",
"export_info",
"=",
"self",
".",
"main_window",
".",
"interfaces",
".",
"get_cairo_export_info",
"(",
"filetype",
")",
"if",
"export_i... | Exports grid to the PDF file filepath
Parameters
----------
filepath: String
\tPath of file to export
filetype in ["pdf", "svg"]
\tType of file to export | [
"Exports",
"grid",
"to",
"the",
"PDF",
"file",
"filepath"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_main_window_actions.py#L255-L319 | train | 231,185 |
manns/pyspread | pyspread/src/actions/_main_window_actions.py | PrintActions.print_preview | def print_preview(self, print_area, print_data):
"""Launch print preview"""
if cairo is None:
return
print_info = \
self.main_window.interfaces.get_cairo_export_info("Print")
if print_info is None:
# Dialog has been canceled
return
printout_preview = Printout(self.grid, print_data, print_info)
printout_printing = Printout(self.grid, print_data, print_info)
preview = wx.PrintPreview(printout_preview, printout_printing,
print_data)
if not preview.Ok():
# Printout preview failed
return
pfrm = wx.PreviewFrame(preview, self.main_window, _("Print preview"))
pfrm.Initialize()
pfrm.SetPosition(self.main_window.GetPosition())
pfrm.SetSize(self.main_window.GetSize())
pfrm.Show(True) | python | def print_preview(self, print_area, print_data):
"""Launch print preview"""
if cairo is None:
return
print_info = \
self.main_window.interfaces.get_cairo_export_info("Print")
if print_info is None:
# Dialog has been canceled
return
printout_preview = Printout(self.grid, print_data, print_info)
printout_printing = Printout(self.grid, print_data, print_info)
preview = wx.PrintPreview(printout_preview, printout_printing,
print_data)
if not preview.Ok():
# Printout preview failed
return
pfrm = wx.PreviewFrame(preview, self.main_window, _("Print preview"))
pfrm.Initialize()
pfrm.SetPosition(self.main_window.GetPosition())
pfrm.SetSize(self.main_window.GetSize())
pfrm.Show(True) | [
"def",
"print_preview",
"(",
"self",
",",
"print_area",
",",
"print_data",
")",
":",
"if",
"cairo",
"is",
"None",
":",
"return",
"print_info",
"=",
"self",
".",
"main_window",
".",
"interfaces",
".",
"get_cairo_export_info",
"(",
"\"Print\"",
")",
"if",
"pri... | Launch print preview | [
"Launch",
"print",
"preview"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_main_window_actions.py#L325-L353 | train | 231,186 |
manns/pyspread | pyspread/src/actions/_main_window_actions.py | PrintActions.printout | def printout(self, print_area, print_data):
"""Print out print area
See:
http://aspn.activestate.com/ASPN/Mail/Message/wxpython-users/3471083
"""
print_info = \
self.main_window.interfaces.get_cairo_export_info("Print")
if print_info is None:
# Dialog has been canceled
return
pdd = wx.PrintDialogData(print_data)
printer = wx.Printer(pdd)
printout = Printout(self.grid, print_data, print_info)
if printer.Print(self.main_window, printout, True):
self.print_data = \
wx.PrintData(printer.GetPrintDialogData().GetPrintData())
printout.Destroy() | python | def printout(self, print_area, print_data):
"""Print out print area
See:
http://aspn.activestate.com/ASPN/Mail/Message/wxpython-users/3471083
"""
print_info = \
self.main_window.interfaces.get_cairo_export_info("Print")
if print_info is None:
# Dialog has been canceled
return
pdd = wx.PrintDialogData(print_data)
printer = wx.Printer(pdd)
printout = Printout(self.grid, print_data, print_info)
if printer.Print(self.main_window, printout, True):
self.print_data = \
wx.PrintData(printer.GetPrintDialogData().GetPrintData())
printout.Destroy() | [
"def",
"printout",
"(",
"self",
",",
"print_area",
",",
"print_data",
")",
":",
"print_info",
"=",
"self",
".",
"main_window",
".",
"interfaces",
".",
"get_cairo_export_info",
"(",
"\"Print\"",
")",
"if",
"print_info",
"is",
"None",
":",
"# Dialog has been cance... | Print out print area
See:
http://aspn.activestate.com/ASPN/Mail/Message/wxpython-users/3471083 | [
"Print",
"out",
"print",
"area"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_main_window_actions.py#L355-L379 | train | 231,187 |
manns/pyspread | pyspread/src/actions/_main_window_actions.py | ClipboardActions.copy | def copy(self, selection, getter=None, delete=False):
"""Returns code from selection in a tab separated string
Cells that are not in selection are included as empty.
Parameters
----------
selection: Selection object
\tSelection of cells in current table that shall be copied
getter: Function, defaults to _get_code
\tGetter function for copy content
delete: Bool
\tDeletes all cells inside selection
"""
if getter is None:
getter = self._get_code
tab = self.grid.current_table
selection_bbox = selection.get_bbox()
if not selection_bbox:
# There is no selection
bb_top, bb_left = self.grid.actions.cursor[:2]
bb_bottom, bb_right = bb_top, bb_left
else:
replace_none = self.main_window.grid.actions._replace_bbox_none
(bb_top, bb_left), (bb_bottom, bb_right) = \
replace_none(selection.get_bbox())
data = []
for __row in xrange(bb_top, bb_bottom + 1):
data.append([])
for __col in xrange(bb_left, bb_right + 1):
# Only copy content if cell is in selection or
# if there is no selection
if (__row, __col) in selection or not selection_bbox:
content = getter((__row, __col, tab))
# Delete cell if delete flag is set
if delete:
try:
self.grid.code_array.pop((__row, __col, tab))
except KeyError:
pass
# Store data
if content is None:
data[-1].append(u"")
else:
data[-1].append(content)
else:
data[-1].append(u"")
return "\n".join("\t".join(line) for line in data) | python | def copy(self, selection, getter=None, delete=False):
"""Returns code from selection in a tab separated string
Cells that are not in selection are included as empty.
Parameters
----------
selection: Selection object
\tSelection of cells in current table that shall be copied
getter: Function, defaults to _get_code
\tGetter function for copy content
delete: Bool
\tDeletes all cells inside selection
"""
if getter is None:
getter = self._get_code
tab = self.grid.current_table
selection_bbox = selection.get_bbox()
if not selection_bbox:
# There is no selection
bb_top, bb_left = self.grid.actions.cursor[:2]
bb_bottom, bb_right = bb_top, bb_left
else:
replace_none = self.main_window.grid.actions._replace_bbox_none
(bb_top, bb_left), (bb_bottom, bb_right) = \
replace_none(selection.get_bbox())
data = []
for __row in xrange(bb_top, bb_bottom + 1):
data.append([])
for __col in xrange(bb_left, bb_right + 1):
# Only copy content if cell is in selection or
# if there is no selection
if (__row, __col) in selection or not selection_bbox:
content = getter((__row, __col, tab))
# Delete cell if delete flag is set
if delete:
try:
self.grid.code_array.pop((__row, __col, tab))
except KeyError:
pass
# Store data
if content is None:
data[-1].append(u"")
else:
data[-1].append(content)
else:
data[-1].append(u"")
return "\n".join("\t".join(line) for line in data) | [
"def",
"copy",
"(",
"self",
",",
"selection",
",",
"getter",
"=",
"None",
",",
"delete",
"=",
"False",
")",
":",
"if",
"getter",
"is",
"None",
":",
"getter",
"=",
"self",
".",
"_get_code",
"tab",
"=",
"self",
".",
"grid",
".",
"current_table",
"selec... | Returns code from selection in a tab separated string
Cells that are not in selection are included as empty.
Parameters
----------
selection: Selection object
\tSelection of cells in current table that shall be copied
getter: Function, defaults to _get_code
\tGetter function for copy content
delete: Bool
\tDeletes all cells inside selection | [
"Returns",
"code",
"from",
"selection",
"in",
"a",
"tab",
"separated",
"string"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_main_window_actions.py#L416-L481 | train | 231,188 |
manns/pyspread | pyspread/src/actions/_main_window_actions.py | ClipboardActions.img2code | def img2code(self, key, img):
"""Pastes wx.Image into single cell"""
code_template = \
"wx.ImageFromData({width}, {height}, " + \
"bz2.decompress(base64.b64decode('{data}'))).ConvertToBitmap()"
code_alpha_template = \
"wx.ImageFromDataWithAlpha({width}, {height}, " + \
"bz2.decompress(base64.b64decode('{data}')), " + \
"bz2.decompress(base64.b64decode('{alpha}'))).ConvertToBitmap()"
data = base64.b64encode(bz2.compress(img.GetData(), 9))
if img.HasAlpha():
alpha = base64.b64encode(bz2.compress(img.GetAlphaData(), 9))
code_str = code_alpha_template.format(
width=img.GetWidth(), height=img.GetHeight(),
data=data, alpha=alpha)
else:
code_str = code_template.format(width=img.GetWidth(),
height=img.GetHeight(), data=data)
return code_str | python | def img2code(self, key, img):
"""Pastes wx.Image into single cell"""
code_template = \
"wx.ImageFromData({width}, {height}, " + \
"bz2.decompress(base64.b64decode('{data}'))).ConvertToBitmap()"
code_alpha_template = \
"wx.ImageFromDataWithAlpha({width}, {height}, " + \
"bz2.decompress(base64.b64decode('{data}')), " + \
"bz2.decompress(base64.b64decode('{alpha}'))).ConvertToBitmap()"
data = base64.b64encode(bz2.compress(img.GetData(), 9))
if img.HasAlpha():
alpha = base64.b64encode(bz2.compress(img.GetAlphaData(), 9))
code_str = code_alpha_template.format(
width=img.GetWidth(), height=img.GetHeight(),
data=data, alpha=alpha)
else:
code_str = code_template.format(width=img.GetWidth(),
height=img.GetHeight(), data=data)
return code_str | [
"def",
"img2code",
"(",
"self",
",",
"key",
",",
"img",
")",
":",
"code_template",
"=",
"\"wx.ImageFromData({width}, {height}, \"",
"+",
"\"bz2.decompress(base64.b64decode('{data}'))).ConvertToBitmap()\"",
"code_alpha_template",
"=",
"\"wx.ImageFromDataWithAlpha({width}, {height}, ... | Pastes wx.Image into single cell | [
"Pastes",
"wx",
".",
"Image",
"into",
"single",
"cell"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_main_window_actions.py#L555-L578 | train | 231,189 |
manns/pyspread | pyspread/src/actions/_main_window_actions.py | ClipboardActions._get_paste_data_gen | def _get_paste_data_gen(self, key, data):
"""Generator for paste data
Can be used in grid.actions.paste
"""
if type(data) is wx._gdi.Bitmap:
code_str = self.bmp2code(key, data)
return [[code_str]]
else:
return (line.split("\t") for line in data.split("\n")) | python | def _get_paste_data_gen(self, key, data):
"""Generator for paste data
Can be used in grid.actions.paste
"""
if type(data) is wx._gdi.Bitmap:
code_str = self.bmp2code(key, data)
return [[code_str]]
else:
return (line.split("\t") for line in data.split("\n")) | [
"def",
"_get_paste_data_gen",
"(",
"self",
",",
"key",
",",
"data",
")",
":",
"if",
"type",
"(",
"data",
")",
"is",
"wx",
".",
"_gdi",
".",
"Bitmap",
":",
"code_str",
"=",
"self",
".",
"bmp2code",
"(",
"key",
",",
"data",
")",
"return",
"[",
"[",
... | Generator for paste data
Can be used in grid.actions.paste | [
"Generator",
"for",
"paste",
"data"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_main_window_actions.py#L585-L596 | train | 231,190 |
manns/pyspread | pyspread/src/actions/_main_window_actions.py | ClipboardActions.paste | def paste(self, key, data):
"""Pastes data into grid
Parameters
----------
key: 2-Tuple of Integer
\tTop left cell
data: String or wx.Bitmap
\tTab separated string of paste data
\tor paste data image
"""
data_gen = self._get_paste_data_gen(key, data)
self.grid.actions.paste(key[:2], data_gen, freq=1000)
self.main_window.grid.ForceRefresh() | python | def paste(self, key, data):
"""Pastes data into grid
Parameters
----------
key: 2-Tuple of Integer
\tTop left cell
data: String or wx.Bitmap
\tTab separated string of paste data
\tor paste data image
"""
data_gen = self._get_paste_data_gen(key, data)
self.grid.actions.paste(key[:2], data_gen, freq=1000)
self.main_window.grid.ForceRefresh() | [
"def",
"paste",
"(",
"self",
",",
"key",
",",
"data",
")",
":",
"data_gen",
"=",
"self",
".",
"_get_paste_data_gen",
"(",
"key",
",",
"data",
")",
"self",
".",
"grid",
".",
"actions",
".",
"paste",
"(",
"key",
"[",
":",
"2",
"]",
",",
"data_gen",
... | Pastes data into grid
Parameters
----------
key: 2-Tuple of Integer
\tTop left cell
data: String or wx.Bitmap
\tTab separated string of paste data
\tor paste data image | [
"Pastes",
"data",
"into",
"grid"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_main_window_actions.py#L598-L615 | train | 231,191 |
manns/pyspread | pyspread/src/actions/_main_window_actions.py | ClipboardActions._get_pasteas_data | def _get_pasteas_data(self, dim, obj):
"""Returns list of lists of obj than has dimensionality dim
Parameters
----------
dim: Integer
\tDimensionality of obj
obj: Object
\tIterable object of dimensionality dim
"""
if dim == 0:
return [[repr(obj)]]
elif dim == 1:
return [[repr(o)] for o in obj]
elif dim == 2:
return [map(repr, o) for o in obj] | python | def _get_pasteas_data(self, dim, obj):
"""Returns list of lists of obj than has dimensionality dim
Parameters
----------
dim: Integer
\tDimensionality of obj
obj: Object
\tIterable object of dimensionality dim
"""
if dim == 0:
return [[repr(obj)]]
elif dim == 1:
return [[repr(o)] for o in obj]
elif dim == 2:
return [map(repr, o) for o in obj] | [
"def",
"_get_pasteas_data",
"(",
"self",
",",
"dim",
",",
"obj",
")",
":",
"if",
"dim",
"==",
"0",
":",
"return",
"[",
"[",
"repr",
"(",
"obj",
")",
"]",
"]",
"elif",
"dim",
"==",
"1",
":",
"return",
"[",
"[",
"repr",
"(",
"o",
")",
"]",
"for... | Returns list of lists of obj than has dimensionality dim
Parameters
----------
dim: Integer
\tDimensionality of obj
obj: Object
\tIterable object of dimensionality dim | [
"Returns",
"list",
"of",
"lists",
"of",
"obj",
"than",
"has",
"dimensionality",
"dim"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_main_window_actions.py#L617-L634 | train | 231,192 |
manns/pyspread | pyspread/src/actions/_main_window_actions.py | ClipboardActions.paste_as | def paste_as(self, key, data):
"""Paste and transform data
Data may be given as a Python code as well as a tab separated
multi-line strings similar to paste.
"""
def error_msg(err):
msg = _("Error evaluating data: ") + str(err)
post_command_event(self.main_window, self.StatusBarMsg, text=msg)
interfaces = self.main_window.interfaces
key = self.main_window.grid.actions.cursor
try:
obj = ast.literal_eval(data)
except (SyntaxError, AttributeError):
# This is no Python code so te try to interpret it as paste data
try:
obj = [map(ast.literal_eval, line.split("\t"))
for line in data.split("\n")]
except Exception, err:
# This must just be text.
try:
obj = [line.split('\t') for line in data.split('\n')]
except Exception, err:
# Now I really have no idea
error_msg(err)
return
except ValueError, err:
error_msg(err)
return
parameters = interfaces.get_pasteas_parameters_from_user(obj)
if parameters is None:
# Dialog aborted
return
paste_data = self._get_pasteas_data(parameters["dim"], obj)
if parameters["transpose"]:
paste_data = zip(*paste_data)
self.main_window.grid.actions.paste(key, paste_data, freq=1000) | python | def paste_as(self, key, data):
"""Paste and transform data
Data may be given as a Python code as well as a tab separated
multi-line strings similar to paste.
"""
def error_msg(err):
msg = _("Error evaluating data: ") + str(err)
post_command_event(self.main_window, self.StatusBarMsg, text=msg)
interfaces = self.main_window.interfaces
key = self.main_window.grid.actions.cursor
try:
obj = ast.literal_eval(data)
except (SyntaxError, AttributeError):
# This is no Python code so te try to interpret it as paste data
try:
obj = [map(ast.literal_eval, line.split("\t"))
for line in data.split("\n")]
except Exception, err:
# This must just be text.
try:
obj = [line.split('\t') for line in data.split('\n')]
except Exception, err:
# Now I really have no idea
error_msg(err)
return
except ValueError, err:
error_msg(err)
return
parameters = interfaces.get_pasteas_parameters_from_user(obj)
if parameters is None:
# Dialog aborted
return
paste_data = self._get_pasteas_data(parameters["dim"], obj)
if parameters["transpose"]:
paste_data = zip(*paste_data)
self.main_window.grid.actions.paste(key, paste_data, freq=1000) | [
"def",
"paste_as",
"(",
"self",
",",
"key",
",",
"data",
")",
":",
"def",
"error_msg",
"(",
"err",
")",
":",
"msg",
"=",
"_",
"(",
"\"Error evaluating data: \"",
")",
"+",
"str",
"(",
"err",
")",
"post_command_event",
"(",
"self",
".",
"main_window",
"... | Paste and transform data
Data may be given as a Python code as well as a tab separated
multi-line strings similar to paste. | [
"Paste",
"and",
"transform",
"data"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_main_window_actions.py#L636-L684 | train | 231,193 |
manns/pyspread | pyspread/src/actions/_main_window_actions.py | MacroActions.execute_macros | def execute_macros(self):
"""Executes macros and marks grid as changed"""
# Mark content as changed
post_command_event(self.main_window, self.ContentChangedMsg)
(result, err) = self.grid.code_array.execute_macros()
# Post event to macro dialog
post_command_event(self.main_window, self.MacroErrorMsg,
msg=result, err=err) | python | def execute_macros(self):
"""Executes macros and marks grid as changed"""
# Mark content as changed
post_command_event(self.main_window, self.ContentChangedMsg)
(result, err) = self.grid.code_array.execute_macros()
# Post event to macro dialog
post_command_event(self.main_window, self.MacroErrorMsg,
msg=result, err=err) | [
"def",
"execute_macros",
"(",
"self",
")",
":",
"# Mark content as changed",
"post_command_event",
"(",
"self",
".",
"main_window",
",",
"self",
".",
"ContentChangedMsg",
")",
"(",
"result",
",",
"err",
")",
"=",
"self",
".",
"grid",
".",
"code_array",
".",
... | Executes macros and marks grid as changed | [
"Executes",
"macros",
"and",
"marks",
"grid",
"as",
"changed"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_main_window_actions.py#L695-L705 | train | 231,194 |
manns/pyspread | pyspread/src/actions/_main_window_actions.py | MacroActions.open_macros | def open_macros(self, filepath):
"""Loads macros from file and marks grid as changed
Parameters
----------
filepath: String
\tPath to macro file
"""
try:
wx.BeginBusyCursor()
self.main_window.grid.Disable()
with open(filepath) as macro_infile:
# Enter safe mode
self.main_window.grid.actions.enter_safe_mode()
post_command_event(self.main_window, self.SafeModeEntryMsg)
# Mark content as changed
post_command_event(self.main_window, self.ContentChangedMsg)
macrocode = macro_infile.read()
self.grid.code_array.macros += "\n" + macrocode.strip("\n")
self.grid.main_window.macro_panel.codetext_ctrl.SetText(
self.grid.code_array.macros)
except IOError:
msg = _("Error opening file {filepath}.").format(filepath=filepath)
post_command_event(self.main_window, self.StatusBarMsg, text=msg)
return False
finally:
self.main_window.grid.Enable()
wx.EndBusyCursor()
# Mark content as changed
try:
post_command_event(self.main_window, self.ContentChangedMsg)
except TypeError:
# The main window does not exist any more
pass | python | def open_macros(self, filepath):
"""Loads macros from file and marks grid as changed
Parameters
----------
filepath: String
\tPath to macro file
"""
try:
wx.BeginBusyCursor()
self.main_window.grid.Disable()
with open(filepath) as macro_infile:
# Enter safe mode
self.main_window.grid.actions.enter_safe_mode()
post_command_event(self.main_window, self.SafeModeEntryMsg)
# Mark content as changed
post_command_event(self.main_window, self.ContentChangedMsg)
macrocode = macro_infile.read()
self.grid.code_array.macros += "\n" + macrocode.strip("\n")
self.grid.main_window.macro_panel.codetext_ctrl.SetText(
self.grid.code_array.macros)
except IOError:
msg = _("Error opening file {filepath}.").format(filepath=filepath)
post_command_event(self.main_window, self.StatusBarMsg, text=msg)
return False
finally:
self.main_window.grid.Enable()
wx.EndBusyCursor()
# Mark content as changed
try:
post_command_event(self.main_window, self.ContentChangedMsg)
except TypeError:
# The main window does not exist any more
pass | [
"def",
"open_macros",
"(",
"self",
",",
"filepath",
")",
":",
"try",
":",
"wx",
".",
"BeginBusyCursor",
"(",
")",
"self",
".",
"main_window",
".",
"grid",
".",
"Disable",
"(",
")",
"with",
"open",
"(",
"filepath",
")",
"as",
"macro_infile",
":",
"# Ent... | Loads macros from file and marks grid as changed
Parameters
----------
filepath: String
\tPath to macro file | [
"Loads",
"macros",
"from",
"file",
"and",
"marks",
"grid",
"as",
"changed"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_main_window_actions.py#L707-L751 | train | 231,195 |
manns/pyspread | pyspread/src/actions/_main_window_actions.py | MacroActions.save_macros | def save_macros(self, filepath, macros):
"""Saves macros to file
Parameters
----------
filepath: String
\tPath to macro file
macros: String
\tMacro code
"""
io_error_text = _("Error writing to file {filepath}.")
io_error_text = io_error_text.format(filepath=filepath)
# Make sure that old macro file does not get lost on abort save
tmpfile = filepath + "~"
try:
wx.BeginBusyCursor()
self.main_window.grid.Disable()
with open(tmpfile, "w") as macro_outfile:
macro_outfile.write(macros)
# Move save file from temp file to filepath
try:
os.rename(tmpfile, filepath)
except OSError:
# No tmp file present
pass
except IOError:
try:
post_command_event(self.main_window, self.StatusBarMsg,
text=io_error_text)
except TypeError:
# The main window does not exist any more
pass
return False
finally:
self.main_window.grid.Enable()
wx.EndBusyCursor() | python | def save_macros(self, filepath, macros):
"""Saves macros to file
Parameters
----------
filepath: String
\tPath to macro file
macros: String
\tMacro code
"""
io_error_text = _("Error writing to file {filepath}.")
io_error_text = io_error_text.format(filepath=filepath)
# Make sure that old macro file does not get lost on abort save
tmpfile = filepath + "~"
try:
wx.BeginBusyCursor()
self.main_window.grid.Disable()
with open(tmpfile, "w") as macro_outfile:
macro_outfile.write(macros)
# Move save file from temp file to filepath
try:
os.rename(tmpfile, filepath)
except OSError:
# No tmp file present
pass
except IOError:
try:
post_command_event(self.main_window, self.StatusBarMsg,
text=io_error_text)
except TypeError:
# The main window does not exist any more
pass
return False
finally:
self.main_window.grid.Enable()
wx.EndBusyCursor() | [
"def",
"save_macros",
"(",
"self",
",",
"filepath",
",",
"macros",
")",
":",
"io_error_text",
"=",
"_",
"(",
"\"Error writing to file {filepath}.\"",
")",
"io_error_text",
"=",
"io_error_text",
".",
"format",
"(",
"filepath",
"=",
"filepath",
")",
"# Make sure tha... | Saves macros to file
Parameters
----------
filepath: String
\tPath to macro file
macros: String
\tMacro code | [
"Saves",
"macros",
"to",
"file"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_main_window_actions.py#L753-L797 | train | 231,196 |
manns/pyspread | pyspread/src/actions/_main_window_actions.py | HelpActions.launch_help | def launch_help(self, helpname, filename):
"""Generic help launcher
Launches HTMLWindow that shows content of filename
or the Internet page with the filename url
Parameters
----------
filename: String
\thtml file or url
"""
# Set up window
position = config["help_window_position"]
size = config["help_window_size"]
self.help_window = wx.Frame(self.main_window, -1,
helpname, position, size)
self.help_htmlwindow = wx.html.HtmlWindow(self.help_window, -1,
(0, 0), size)
self.help_window.Bind(wx.EVT_MOVE, self.OnHelpMove)
self.help_window.Bind(wx.EVT_SIZE, self.OnHelpSize)
self.help_htmlwindow.Bind(wx.EVT_RIGHT_DOWN, self.OnHelpBack)
self.help_htmlwindow.Bind(wx.html.EVT_HTML_LINK_CLICKED,
lambda e: self.open_external_links(e))
self.help_htmlwindow.Bind(wx.EVT_MOUSEWHEEL,
lambda e: self.zoom_html(e))
# Get help data
current_path = os.getcwd()
os.chdir(get_help_path())
try:
if os.path.isfile(filename):
self.help_htmlwindow.LoadFile(filename)
else:
self.help_htmlwindow.LoadPage(filename)
except IOError:
self.help_htmlwindow.LoadPage(filename)
# Show tutorial window
self.help_window.Show()
os.chdir(current_path) | python | def launch_help(self, helpname, filename):
"""Generic help launcher
Launches HTMLWindow that shows content of filename
or the Internet page with the filename url
Parameters
----------
filename: String
\thtml file or url
"""
# Set up window
position = config["help_window_position"]
size = config["help_window_size"]
self.help_window = wx.Frame(self.main_window, -1,
helpname, position, size)
self.help_htmlwindow = wx.html.HtmlWindow(self.help_window, -1,
(0, 0), size)
self.help_window.Bind(wx.EVT_MOVE, self.OnHelpMove)
self.help_window.Bind(wx.EVT_SIZE, self.OnHelpSize)
self.help_htmlwindow.Bind(wx.EVT_RIGHT_DOWN, self.OnHelpBack)
self.help_htmlwindow.Bind(wx.html.EVT_HTML_LINK_CLICKED,
lambda e: self.open_external_links(e))
self.help_htmlwindow.Bind(wx.EVT_MOUSEWHEEL,
lambda e: self.zoom_html(e))
# Get help data
current_path = os.getcwd()
os.chdir(get_help_path())
try:
if os.path.isfile(filename):
self.help_htmlwindow.LoadFile(filename)
else:
self.help_htmlwindow.LoadPage(filename)
except IOError:
self.help_htmlwindow.LoadPage(filename)
# Show tutorial window
self.help_window.Show()
os.chdir(current_path) | [
"def",
"launch_help",
"(",
"self",
",",
"helpname",
",",
"filename",
")",
":",
"# Set up window",
"position",
"=",
"config",
"[",
"\"help_window_position\"",
"]",
"size",
"=",
"config",
"[",
"\"help_window_size\"",
"]",
"self",
".",
"help_window",
"=",
"wx",
"... | Generic help launcher
Launches HTMLWindow that shows content of filename
or the Internet page with the filename url
Parameters
----------
filename: String
\thtml file or url | [
"Generic",
"help",
"launcher"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_main_window_actions.py#L803-L853 | train | 231,197 |
manns/pyspread | pyspread/src/actions/_main_window_actions.py | HelpActions.OnHelpMove | def OnHelpMove(self, event):
"""Help window move event handler stores position in config"""
position = event.GetPosition()
config["help_window_position"] = repr((position.x, position.y))
event.Skip() | python | def OnHelpMove(self, event):
"""Help window move event handler stores position in config"""
position = event.GetPosition()
config["help_window_position"] = repr((position.x, position.y))
event.Skip() | [
"def",
"OnHelpMove",
"(",
"self",
",",
"event",
")",
":",
"position",
"=",
"event",
".",
"GetPosition",
"(",
")",
"config",
"[",
"\"help_window_position\"",
"]",
"=",
"repr",
"(",
"(",
"position",
".",
"x",
",",
"position",
".",
"y",
")",
")",
"event",... | Help window move event handler stores position in config | [
"Help",
"window",
"move",
"event",
"handler",
"stores",
"position",
"in",
"config"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_main_window_actions.py#L861-L867 | train | 231,198 |
manns/pyspread | pyspread/src/actions/_main_window_actions.py | HelpActions.OnHelpSize | def OnHelpSize(self, event):
"""Help window size event handler stores size in config"""
size = event.GetSize()
config["help_window_size"] = repr((size.width, size.height))
event.Skip() | python | def OnHelpSize(self, event):
"""Help window size event handler stores size in config"""
size = event.GetSize()
config["help_window_size"] = repr((size.width, size.height))
event.Skip() | [
"def",
"OnHelpSize",
"(",
"self",
",",
"event",
")",
":",
"size",
"=",
"event",
".",
"GetSize",
"(",
")",
"config",
"[",
"\"help_window_size\"",
"]",
"=",
"repr",
"(",
"(",
"size",
".",
"width",
",",
"size",
".",
"height",
")",
")",
"event",
".",
"... | Help window size event handler stores size in config | [
"Help",
"window",
"size",
"event",
"handler",
"stores",
"size",
"in",
"config"
] | 0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0 | https://github.com/manns/pyspread/blob/0e2fd44c2e0f06605efc3058c20a43a8c1f9e7e0/pyspread/src/actions/_main_window_actions.py#L869-L875 | train | 231,199 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.