def get_table(self, db_name, mols=True, mol_only=True):
results = SqliteDict(db_name,
encode=json.dumps,
decode=json.loads,
autocommit=True)
result_table = pd.DataFrame(results.values())
print(len(result_table), sum(~result_table['∆∆G'].isna()))
result_table['LE'] = result_table.apply(LE, 1)
rank = result_table.apply(ranker, axis=1).rank()
m = np.nanmax(rank.values)
result_table['%Rank'] = rank / m * 100
result_table['N_hits'] = result_table.regarded.apply(
lambda x: len(x) if str(x) != 'nan' else float('nan'))
result_table = result_table.loc[~result_table.smiles.isna(
)].sort_values(['%Rank'], axis=0)
if mols:
result_table['mol3D'] = result_table['name'].apply(get_mol3D)
# result_table['mol2D'] = result_table['name'].apply(get_mol2D)
PandasTools.AddMoleculeColumnToFrame(result_table, 'smiles',
'mol2D')
if mol_only:
result_table = result_table.loc[~result_table.mol3D.isna()]
return result_table
for word in wordToSlugs.keys():
if len(word) < 3:
continue
ids = sorted([bookmap[slug][0] for slug in wordToSlugs[word]])
with open(osp.join(WOUT, word), "wt", encoding="utf-8") as fp:
fp.write("".join(ids))
# make sure CAUTION exists
with open(osp.join(WOUT, "CAUTION"), "at", encoding="utf-8") as fp:
fp.write("")
# write the AllAvailable file
with open(osp.join(WOUT, "AllAvailable"), "wt", encoding="utf-8") as fp:
fp.write("%s-%s" % ("0" * Dbooks, last))
# write out a list of the images for possible prefetch...
with open(osp.join(CONTENT, "images.json"), "wt", encoding="utf-8") as fp:
json.dump([osp.relpath(path, OUT) for path in imagemap.values()], fp)
# record parameters needed by the js
config = {
"base": args.base,
"digits": Dbooks,
"first": "0" * Dbooks,
"lastReviewed": lastReviewed,
"last": last,
}
with open(osp.join(CONTENT, "config.json"), "wt") as fp:
json.dump(config, fp)
from zk_snark.to_r1cs import code_to_r1cs_with_inputs
from sqlitedict import SqliteDict
import zlib, pickle, sqlite3
from decimal import Decimal
voters_dict = SqliteDict('./Trusted_users_app.sqlite', autocommit=True)
func = """
def qeval(x):
y = x**3
return y + x + 5
"""
voters_list = []
for i in voters_dict.values():
voters_list.append(i)
def proof(name: str):
p, G = get_pg()
with open("CRS", 'r') as crs:
n = int(crs.readline())
A, B, C, summ = [], [], [], []
for i in range(n):
A.append(float(crs.readline()))
B.append(float(crs.readline()))
C.append(float(crs.readline()))
for i in range(n):
summ.append(float(crs.readline()))
pre_cleaning1 = []
pre_cleaning2 = []
pre_cleaning3 = []
pre_cleaning4 = []
pre_cleaning5 = []
for category in categories:
c = 0
print(f"Category = {category}", c)
pua = SqliteDict(f"./../Sqlite/split_texts/{category}.sqlite",
tablename="value",
flag="r")
#pua_clean = SqliteDict(f"{category}_clean.sqlite", tablename="value", journal_mode="OFF")
for value in pua.values():
try:
y = datetime.fromtimestamp(value["timestamp"] // 1000).year
if y <= 2012:
pre_cleaning1.append(
re.sub("[^A-Za-z]+", ' ',
str(value["text"]).lower()))
elif y <= 2015:
pre_cleaning2.append(
re.sub("[^A-Za-z]+", ' ',
str(value["text"]).lower()))
elif y <= 2017:
pre_cleaning3.append(
re.sub("[^A-Za-z]+", ' ',
str(value["text"]).lower()))
elif y <= 2018:
import json
books = SqliteDict("allbooks.sqlite", autocommit=True)
for page in range(1, 10000):
if page % 100 == 0:
print(page)
url = (
"http://test.tarheelreader.org/find/"
"?search=&category=&reviewed=&audience=&language=&"
f"page={page}&json=1"
)
resp = requests.get(url)
r = resp.json()
for b in r["books"]:
if b["slug"] in books:
continue
url = "http://test.tarheelreader.org/book-as-json/" f'?slug={b["slug"]}'
resp = requests.get(url)
book = resp.json()
books[b["slug"]] = book
if not r["more"]:
break
rows = sorted(books.values(), key=lambda b: b["ID"])
with gzip.open("books.json.gz", "wt", encoding="utf-8") as fp:
json.dump(rows, fp)
class SQLiteMetadataStore(MetadataStoreInterface):
name = 'sqlite'
def __init__(self, db_path: str, no_conns_and_vars=False):
from sqlitedict import SqliteDict
self.db_path = db_path
if not no_conns_and_vars:
self.conn_connections = SqliteDict(
self.db_path, tablename=Settings.connections_table_name)
self.conn_variables = SqliteDict(
self.db_path, tablename=Settings.variables_table_name)
self.conn_dag_deployments = SqliteDict(
self.db_path, tablename=Settings.dag_deployments_table_name)
def close(self):
self.conn_connections.close()
self.conn_variables.close()
self.conn_dag_deployments.close()
def exists(self) -> bool:
return Path(self.db_path).exists()
def migrate(self):
open(str(self.db_path), 'a').close()
def get_connection(self, conn_id: str) -> Connection:
if conn_id not in self.conn_connections.keys():
raise MetadataObjectNotFound(f'Connection "{conn_id}" is not set')
return self.conn_connections[conn_id]
def get_connections(self,
to_dict: bool = False
) -> List[Union[dict, Connection]]:
return [
conn.__dict__ if to_dict else conn
for conn in self.conn_connections.values()
]
def set_connection(self, conn: Connection):
self.conn_connections[conn.conn_id] = conn
self.conn_connections.commit()
def delete_connection(self, conn: Union[str, Connection]):
del self.conn_connections[conn.conn_id if isinstance(conn, Connection
) else conn]
self.conn_connections.commit()
def get_variable(self, variable_id: str) -> Variable:
if variable_id not in self.conn_variables.keys():
raise MetadataObjectNotFound(
f'Variable "{variable_id}" is not set')
return self.conn_variables[variable_id]
def get_variables(self,
to_dict: bool = False) -> List[Union[dict, Variable]]:
return [
var.dict_contents() if to_dict else var
for var in self.conn_variables.values()
]
def set_variable(self, variable: Variable):
self.conn_variables[variable.id] = variable
self.conn_variables.commit()
def delete_variable(self, variable: Union[str, Variable]):
del self.conn_variables[variable.id if isinstance(variable, Variable
) else variable]
self.conn_variables.commit()
def get_dag_deployment(self, deployment_hash: str) -> DagDeployment:
if deployment_hash not in self.conn_connections.keys():
raise MetadataObjectNotFound(
f'Dag deployment "{deployment_hash}" is not set')
return self.conn_connections[deployment_hash]
def get_dag_deployments(self,
to_dict: bool = False
) -> List[Union[dict, DagDeployment]]:
return [
x.dict() if to_dict else x
for x in self.conn_dag_deployments.values()
]
def set_dag_deployment(self, dag_deployment: DagDeployment):
self.conn_dag_deployments[
dag_deployment.deployment_hash] = dag_deployment
self.conn_dag_deployments.commit()
