grewpy package

Submodules

grewpy.corpus module

Grew module : anything you want to talk about graphs Graphs are represented either by a dict (called dict-graph), or by an str (str-graph).

class grewpy.corpus.AbstractCorpus

Bases: object

edge_diff(other, edge_criterion=<function AbstractCorpus.<lambda>>)

given two corpora, outputs the number of common edges, only left ones and only right ones. It also outputs precision, recall and f-measure.

edge_diff_up_to(other, edge_transform=<function AbstractCorpus.<lambda>>)

class grewpy.corpus.Corpus(data)

Bases: AbstractCorpus

apply(Grs, strat='main')

clean()

clean the corpus (remove from the backend memory)

count(request, clustering_parameter=[], clustering_keys=[], flat=False)

Count for [request] into [corpus_index] :param request: a string request :param corpus_index: an integer given by the [corpus] function :return: the number of matching of [request] into the corpus

count_feature_values(include=None, exclude=['xpos', 'wordform', 'textform', 'SpaceAfter'])

return a dict with feature names as key and subdict a value for each feature name, the subdict maps existing feature values with the number of occurrences if include is set as a list of string, only feature names in the list are taken into account else exclude defines the list of feature names in the list whihc are not taken into account

get(sent_id)

return a graph corresponding to the sentence id sent_id

get_all()

return a dictionary mapping sentence ids to graphs

get_id()

return the id of the corpus

get_sent_ids()

return the list of sentence ids

run(Grs, strat='main')

search(request, clustering_parameter=[], clustering_keys=[], flat=None, deco=False, bound=None, timeout=None)

Search for [request] into [corpus_index]

Parameters: request (Request): a request corpus_index: an integer given by the [corpus] function

Returns: list: the list of matching of [request] into the corpus

to_conll()

return a CoNLL string for the current corpus

class grewpy.corpus.CorpusDraft(data=None)

Bases: AbstractCorpus, dict

the draft is composed of

• self, a dict mapping sentence_id to graphs

• self._sent_ids, a list that specifies the sentence order

apply(fun)

Apply fun to all graphs, return the new Corpus

to_conll()

grewpy.graph module

Grew module: anything you want to talk about graphs

class grewpy.graph.Fs_edge(data)

Bases: dict

compact()

sud style

static parse(s)

convert a string into a dictionary to be used by the constructor. 2 cases:

• s is a dict like string f=v,g=w…

• s in a compact string, like “comp:aux@tense/m”

return GrewError on ill formed input like “f=v,x”

class grewpy.graph.Graph(data=None, **kwargs)

Bases: object

a dict mapping node keys to feature structure

with extra data:

• an extra dict sucs mapping node keys to successors (pair of edge feature,node key)

• the list order containing nodes linearly ordered

• and the `meta`(data) as a dict

Param data: either

• None: return an empty graph

• a json formatted string

• a file name containing a json/conll

• a Graph: return a copy of the graph

• or named arguments: features, sucs, meta and order

apply(Grs, strat='main')

edge(n, m)

given node n and m return the “first” label of an edge between n and m if it exists

edge_diff(other, edge_criterion=<function Graph.<lambda>>) → array

edge difference between two graphs

edge_diff_up_to(other, edge_transform=<function Graph.<lambda>>)

edge_up_to(n, m, criterion)

edges(n, m)

given node n and m, return the set of edges between n and m

edges_up_to(n, m, criterion)

search for edges between n and m verifying some criterion

classmethod from_json(data_json)

from_triples(triples)

greater(n, s)

return True if n > s in g

json_data()

lower(n, m)

given node n and m in g: return True if n < m in g

run(Grs, strat='main')

property sucs

successor relation

to_conll()

return a CoNLL string for the given graph

to_dot()

return a CoNLL string for the given graph

to_sentence(deco=None)

return a SVG code for the given graph

to_svg(deco=None, draw_root=False)

return a SVG code for the given graph

triples()

return the list of edges presented as triples (n,e,s) with n-[e]-> s

grewpy.graph.sud_config = ('1', OrderedDict([('2', ':'), ('deep', '@'), ('type', '/')]))

interfaces

grewpy.grew module

Grew module : anything you want to talk about graph rewriting systems Graphs are represented by dictionaries (nodes, edges, meta informations) GRS can be build via files, explicit constructions or even strings. See doc of GREW

exception grewpy.grew.GrewError(message)

Bases: Exception

A wrapper for grew-related errors

grewpy.grew.request_counter()

grewpy.grew.set_config(data)

Change the configuration used in the next exchanges See https://grew.fr/doc/graph/#edges for details about config

grewpy.grs module

class grewpy.grs.Add_edge(X, e, Y)

Bases: Command

safe()

return a clause list for a safe request

class grewpy.grs.Command(s)

Bases: object

json_data()

safe()

return a clause list for a safe request

class grewpy.grs.Commands(*L)

Bases: list

classmethod from_json(json_data)

json_data()

class grewpy.grs.Delete_edge(X, e, Y)

Bases: Command

safe()

return a clause list for a safe request

class grewpy.grs.Delete_feature(X, f)

Bases: Command

class grewpy.grs.GRS(args)

Bases: object

An abstract GRS. Offers the possibility to apply rewriting. The object is abstract and cannot be changed. For that, use a GRSDraft

UD2bUD = <grewpy.grs.GRS object>

apply(data, strat='main', abstract=True)

run a Grs on a graph or corpus :param grs_data: a graph rewriting system or a Grew string representation of a grs :param G: the graph, either a str (in grew format) or a dict :param strat: the strategy (by default “main”) :return: the rewritten graph and an error if there is not exaclty one output graph

json()

run(data, strat='main')

run a Grs on a graph :param data: a graph or an AbstractCorpus :param strat: the strategy (by default “main”) :return: a dictionary mapping sid to the list of rewritten graphs

class grewpy.grs.GRSDraft(args=None)

Bases: Package

A GRSDraft is a structure that gives access to the internals of a Graph Rewriting System: packages, rules, patterns, strategies, etc It cannot be used to perform rewriting, for that, use a GRS

onf(strat_name='main')

rules()

safe_rules()

create a new grs with application of safe to each rule. self.rules() are supposed to contain only Commands of length 1 that support safe method

save(filename)

class grewpy.grs.Package

Bases: dict

dict mapping names to rule/package/strategies

classmethod from_json(json_data)

json_data()

packages()

rules()

strategies()

class grewpy.grs.Request(*L)

Bases: object

lists of ClauseList

append(*L)

Append a new RequestItem to the Request L is given either as a pair (s,t) with “s in {‘pattern’,’without’,’meta’} and t : str or L[0] is a RequestItem

classmethod from_json(json_data)

global_(*L)

json_data()

named_entities()

classmethod parse(string_request)

static parse_request(s: str) → List[Tuple[str, str]]

pattern(*L)

with_(*L)

without(*L)

class grewpy.grs.RequestItem(sort: str, *L)

Bases: object

classmethod from_json(json_data: Any)

json_data()

class grewpy.grs.Rule(request: Request, cmd_list: Commands, lexicons=None)

Bases: object

classmethod from_json(json_data)

json_data()

grewpy.grs.check(L)

grewpy.grs.constant_UD2bUD(cls)

Module contents

Grew python library All you need to use grew See grew online documentation for global informations