def read_networks(pathInFolder, directed):
"""
Translating networks and corresponding node-/ and edgeTables to graphs
>>> allDicts = read_networks(pathinFolder)
:param pathInFolder: Path to directory
:returns: List of [networkTable, nodes, edges, nameGUID, graphs]
"""
networkTable = pd.read_perseus(path.join(pathInFolder, "networks.txt"))
nodes = OrderedDict()
edges = OrderedDict()
nameGUID = OrderedDict()
graphs = OrderedDict()
for Name, GUID in zip(networkTable.Name, networkTable.GUID):
if directed == 1:
G = nx.DiGraph()
else:
G = nx.Graph()
nodeTable = pd.read_perseus(
path.join(pathInFolder, GUID + "_nodes.txt"))
edgeTable = pd.read_perseus(
path.join(pathInFolder, GUID + "_edges.txt"))
nodes[GUID] = nodeTable
edges[GUID] = edgeTable
nameGUID[Name] = GUID
graphs[GUID] = G
for Node in nodeTable.Node:
G.add_node(Node)
for Source, Target in zip(edgeTable.Source, edgeTable.Target):
G.add_edge(Source, Target)
allDicts = [networkTable, nodes, edges, nameGUID, graphs]
return allDicts
import argparse
parser = argparse.ArgumentParser(description='Head processing in Python')
parser.add_argument(
'number_of_rows',
type=int,
help=
'Number of rows. Has to be specified as additional argument in the Perseus Gui'
)
parser.add_argument('input_file', help='Input file containing the matrix')
parser.add_argument('output_file',
help='Output file that should contain the result')
args = parser.parse_args()
from perseuspy import pd
df = pd.read_perseus(args.input_file)
result = df.head(args.number_of_rows)
result.to_perseus(args.output_file)
import sys
from itertools import takewhile
import os
import umap
import perseuspy
import numpy
from perseuspy import pd
from perseuspy.parameters import *
from perseuspy.io.perseus.matrix import *
_, paramfile, infile, outfile = sys.argv # read arguments from the command line
parameters = parse_parameters(paramfile) # parse the parameters file
df = pd.read_perseus(infile) # read the input matrix into a pandas.DataFrame
n_neighbor = intParam(parameters, "Number of neighbors")
n_component = intParam(parameters, "Number of components")
seed = intParam(parameters, "Random state")
m_dist = doubleParam(parameters, "Minimum distance")
metric = singleChoiceParam(parameters, "Metric")
annotations = read_annotations(infile)
if len(annotations) < 2:
sys.exit("The data needs to be grouped")
newDF1 = main_df(infile, df)
newDF1 = newDF1.T
embedding = umap.UMAP(n_neighbors=n_neighbor,
n_components=n_component,
metric=metric,
random_state=seed,
min_dist=m_dist).fit_transform(newDF1)
new_annotations = {}
check_c = {}
c_num = 1
def test_reading_multi_numeric_columns(self):
df = pd.read_perseus(path.join(TEST_DIR, 'matrix4.txt'))
self.assertIsNot(df, None)
self.assertEqual([1, 2, 3], df.values[0][0])
self.assertEqual('1.0;2.0;3.0', to_string(df).splitlines()[-1])
self.assertEqual("#!{Type}M", type_row(df))
def test_reading_example3(self):
df = pd.read_perseus(path.join(TEST_DIR, 'matrix3.txt'))
self.assertIsNot(df, None)
self.assertIsNot(to_string(df), '')
self.assertEqual('#!{Type}' + (3 * 'E\t') + 'C',
'\t'.join(type_row(df).split('\t')[:4]))
def test_reading_example2(self):
df = pd.read_perseus(path.join(TEST_DIR, 'matrix2.txt'))
self.assertIsNot(df, None)
self.assertIsNot(to_string(df), '')
def test_reading_example1(self):
df = pd.read_perseus(path.join(TEST_DIR, 'matrix.txt'))
self.assertIsNot(df, None)
self.assertIsNot(to_string(df), '')
self.assertEqual('#!{Type}' + (15 * 'E\t') + 'T', type_row(df))
import sys from perseuspy import pd from perseuspy.parameters import * _, paramfile, infile, outfile = sys.argv df = pd.read_perseus(infile) number_of_rows = 15 result = df.head(number_of_rows) result.to_perseus(outfile)
def test_reading_numerical_annotation_row(self):
df = pd.read_perseus(path.join(TEST_DIR, 'matrix5.txt'))
self.assertIsNot(df, None)
self.assertIsNot(to_string(df), '')
self.assertEqual('#!{C:Quantity1}1.0\t2.0\t3.0\tnan\tnan\tnan\tnan\tnan\tnan\tnan\tnan\tnan\tnan\tnan',
to_string(df).splitlines()[2])
import argparse
from perseuspy import pd
parser = argparse.ArgumentParser("Head processing")
parser.add_argument("input", help="path of the input file")
parser.add_argument("output", help="path of the output file")
parser.add_argument("--nrow", type=int, default=15, help="the number of row")
arg = parser.parse_args()
df = pd.read_perseus(arg.input)
df_head = df.head(arg.nrow)
df_head.to_perseus(arg.output)