Datasets:

vikp

/

code_search_net_filtered_34k

like 2

if Class is True: Class = self.__class__ if scope is True: scope = STRUCTURESCOPE structural = Class is not None and issubclass(Class,AbstractStructureElement) if reverse: order = reversed descendindex = -1 else: order = lambda x: x #pylint: disable=redefined-variable-type descendindex = 0 child = self parent = self.parent while parent: #pylint: disable=too-many-nested-blocks if len(parent) > 1: returnnext = False for e in order(parent): if e is child: #we found the current item, next item will be the one to return returnnext = True elif returnnext and e.auth and not isinstance(e,AbstractAnnotationLayer) and (not structural or (structural and (not isinstance(e,(AbstractTokenAnnotation,TextContent)) ) )): if structural and isinstance(e,Correction): if not list(e.select(AbstractStructureElement)): #skip-over non-structural correction continue if Class is None or (isinstance(Class,tuple) and (any(isinstance(e,C) for C in Class))) or isinstance(e,Class): return e else: #this is not yet the element of the type we are looking for, we are going to descend again in the very leftmost (rightmost if reversed) branch only while e.data: e = e.data[descendindex] if not isinstance(e, AbstractElement): return None #we've gone too far if e.auth and not isinstance(e,AbstractAnnotationLayer): if Class is None or (isinstance(Class,tuple) and (any(isinstance(e,C) for C in Class))) or isinstance(e,Class): return e else: #descend deeper continue return None #generational iteration child = parent if scope is not None and child.__class__ in scope: #you shall not pass! break parent = parent.parent return None

def next(self, Class=True, scope=True, reverse=False)

Returns the next element, if it is of the specified type and if it does not cross the boundary of the defined scope. Returns None if no next element is found. Non-authoritative elements are never returned. Arguments: * ``Class``: The class to select; any python class subclassed off `'AbstractElement``, may also be a tuple of multiple classes. Set to ``True`` to constrain to the same class as that of the current instance, set to ``None`` to not constrain at all * ``scope``: A list of classes which are never crossed looking for a next element. Set to ``True`` to constrain to a default list of structure elements (Sentence,Paragraph,Division,Event, ListItem,Caption), set to ``None`` to not constrain at all.

def next(self, Class=True, scope=True, reverse=False): """ Returns the next element, if it is of the specified type and if it does not cross the boundary of the defined scope. Returns None if no next element is found. Non-authoritative elements are never returned. Arguments: * ``Class``: The class to select; any python class subclassed off `'AbstractElement``, may also be a tuple of multiple classes. Set to ``True`` to constrain to the same class as that of the current instance, set to ``None`` to not constrain at all * ``scope``: A list of classes which are never crossed looking for a next element. Set to ``True`` to constrain to a default list of structure elements (Sentence,Paragraph,Division,Event, ListItem,Caption), set to ``None`` to not constrain at all. """ if Class is True: Class = self.__class__ if scope is True: scope = STRUCTURESCOPE structural = Class is not None and issubclass(Class,AbstractStructureElement) if reverse: order = reversed descendindex = -1 else: order = lambda x: x #pylint: disable=redefined-variable-type descendindex = 0 child = self parent = self.parent while parent: #pylint: disable=too-many-nested-blocks if len(parent) > 1: returnnext = False for e in order(parent): if e is child: #we found the current item, next item will be the one to return returnnext = True elif returnnext and e.auth and not isinstance(e,AbstractAnnotationLayer) and (not structural or (structural and (not isinstance(e,(AbstractTokenAnnotation,TextContent)) ) )): if structural and isinstance(e,Correction): if not list(e.select(AbstractStructureElement)): #skip-over non-structural correction continue if Class is None or (isinstance(Class,tuple) and (any(isinstance(e,C) for C in Class))) or isinstance(e,Class): return e else: #this is not yet the element of the type we are looking for, we are going to descend again in the very leftmost (rightmost if reversed) branch only while e.data: e = e.data[descendindex] if not isinstance(e, AbstractElement): return None #we've gone too far if e.auth and not isinstance(e,AbstractAnnotationLayer): if Class is None or (isinstance(Class,tuple) and (any(isinstance(e,C) for C in Class))) or isinstance(e,Class): return e else: #descend deeper continue return None #generational iteration child = parent if scope is not None and child.__class__ in scope: #you shall not pass! break parent = parent.parent return None

depth = 0 e = self while True: if e.parent: e = e.parent #pylint: disable=redefined-variable-type else: #no parent, breaking return False if isinstance(e,AbstractStructureElement) or isinstance(e,AbstractSubtokenAnnotation): depth += 1 if depth == 2: return e return False

def finddefaultreference(self)

Find the default reference for text offsets: The parent of the current textcontent's parent (counting only Structure Elements and Subtoken Annotation Elements) Note: This returns not a TextContent element, but its parent. Whether the textcontent actually exists is checked later/elsewhere

def finddefaultreference(self): """ Find the default reference for text offsets: The parent of the current textcontent's parent (counting only Structure Elements and Subtoken Annotation Elements) Note: This returns not a TextContent element, but its parent. Whether the textcontent actually exists is checked later/elsewhere """ depth = 0 e = self while True: if e.parent: e = e.parent #pylint: disable=redefined-variable-type else: #no parent, breaking return False if isinstance(e,AbstractStructureElement) or isinstance(e,AbstractSubtokenAnnotation): depth += 1 if depth == 2: return e return False

l = [] for e in self.data: l += e.items() return l

def items(self)

Returns a depth-first flat list of all items in the document

def items(self): """ Returns a depth-first flat list of all items in the document """ l = [] for e in self.data: l += e.items() return l

finalsolution = None bestscore = None for solution in self: if bestscore == None: bestscore = solution.score() finalsolution = solution elif self.minimize: score = solution.score() if score < bestscore: bestscore = score finalsolution = solution elif not self.minimize: score = solution.score() if score > bestscore: bestscore = score finalsolution = solution return finalsolution

def searchbest(self)

Returns the single best result (if multiple have the same score, the first match is returned)

def searchbest(self): """ Returns the single best result (if multiple have the same score, the first match is returned) """ finalsolution = None bestscore = None for solution in self: if bestscore == None: bestscore = solution.score() finalsolution = solution elif self.minimize: score = solution.score() if score < bestscore: bestscore = score finalsolution = solution elif not self.minimize: score = solution.score() if score > bestscore: bestscore = score finalsolution = solution return finalsolution

solutions = deque([], n) for solution in self: solutions.append(solution) return solutions

def searchlast(self,n=10)

Return the last n results (or possibly less if not found). Note that the last results are not necessarily the best ones! Depending on the search type.

def searchlast(self,n=10): """ Return the last n results (or possibly less if not found). Note that the last results are not necessarily the best ones! Depending on the search type. """ solutions = deque([], n) for solution in self: solutions.append(solution) return solutions

l = [] for word_id, senses,distance in self: for sense, confidence in senses: if not sense in l: l.append(sense) if bestonly: break return l

def senses(self, bestonly=False)

Returns a list of all predicted senses

def senses(self, bestonly=False): """ Returns a list of all predicted senses """ l = [] for word_id, senses,distance in self: for sense, confidence in senses: if not sense in l: l.append(sense) if bestonly: break return l

if self.children: return sum( ( c.size() for c in self.children.values() ) ) + 1 else: return 1

def size(self)

Size is number of nodes under the trie, including the current node

def size(self): """ Size is number of nodes under the trie, including the current node """ if self.children: return sum( ( c.size() for c in self.children.values() ) ) + 1 else: return 1

global namespaces return self.tree.xpath(expression, namespaces=namespaces)

def xpath(self, expression)

Executes an xpath expression using the correct namespaces

def xpath(self, expression): """ Executes an xpath expression using the correct namespaces """ global namespaces return self.tree.xpath(expression, namespaces=namespaces)

''' Given a function to map from an ID to an underlying object, and a function to map from an underlying object to the concrete GraphQLObjectType it corresponds to, constructs a `Node` interface that objects can implement, and a field config for a `node` root field. If the type_resolver is omitted, object resolution on the interface will be handled with the `isTypeOf` method on object types, as with any GraphQL interface without a provided `resolveType` method. ''' node_interface = GraphQLInterfaceType( 'Node', description='An object with an ID', fields=lambda: OrderedDict(( ('id', GraphQLField( GraphQLNonNull(GraphQLID), description='The id of the object.', resolver=id_resolver, )), )), resolve_type=type_resolver ) node_field = GraphQLField( node_interface, description='Fetches an object given its ID', args=OrderedDict(( ('id', GraphQLArgument( GraphQLNonNull(GraphQLID), description='The ID of an object' )), )), resolver=lambda obj, args, *_: id_fetcher(args.get('id'), *_) ) return node_interface, node_field

def node_definitions(id_fetcher, type_resolver=None, id_resolver=None)

Given a function to map from an ID to an underlying object, and a function to map from an underlying object to the concrete GraphQLObjectType it corresponds to, constructs a `Node` interface that objects can implement, and a field config for a `node` root field. If the type_resolver is omitted, object resolution on the interface will be handled with the `isTypeOf` method on object types, as with any GraphQL interface without a provided `resolveType` method.

def node_definitions(id_fetcher, type_resolver=None, id_resolver=None): """ Given a function to map from an ID to an underlying object, and a function to map from an underlying object to the concrete GraphQLObjectType it corresponds to, constructs a `Node` interface that objects can implement, and a field config for a `node` root field. If the type_resolver is omitted, object resolution on the interface will be handled with the `isTypeOf` method on object types, as with any GraphQL interface without a provided `resolveType` method. """ ''' Given a function to map from an ID to an underlying object, and a function to map from an underlying object to the concrete GraphQLObjectType it corresponds to, constructs a `Node` interface that objects can implement, and a field config for a `node` root field. If the type_resolver is omitted, object resolution on the interface will be handled with the `isTypeOf` method on object types, as with any GraphQL interface without a provided `resolveType` method. ''' node_interface = GraphQLInterfaceType( 'Node', description='An object with an ID', fields=lambda: OrderedDict(( ('id', GraphQLField( GraphQLNonNull(GraphQLID), description='The id of the object.', resolver=id_resolver, )), )), resolve_type=type_resolver ) node_field = GraphQLField( node_interface, description='Fetches an object given its ID', args=OrderedDict(( ('id', GraphQLArgument( GraphQLNonNull(GraphQLID), description='The ID of an object' )), )), resolver=lambda obj, args, *_: id_fetcher(args.get('id'), *_) ) return node_interface, node_field

''' Given an optional cursor and a default offset, returns the offset to use; if the cursor contains a valid offset, that will be used, otherwise it will be the default. ''' if not is_str(cursor): return default_offset offset = cursor_to_offset(cursor) try: return int(offset) except: return default_offset

def get_offset_with_default(cursor=None, default_offset=0)

Given an optional cursor and a default offset, returns the offset to use; if the cursor contains a valid offset, that will be used, otherwise it will be the default.

def get_offset_with_default(cursor=None, default_offset=0): """ Given an optional cursor and a default offset, returns the offset to use; if the cursor contains a valid offset, that will be used, otherwise it will be the default. """ ''' Given an optional cursor and a default offset, returns the offset to use; if the cursor contains a valid offset, that will be used, otherwise it will be the default. ''' if not is_str(cursor): return default_offset offset = cursor_to_offset(cursor) try: return int(offset) except: return default_offset

# Get a list of node ids from the edge data nodes = set(e['source'] for e in edges) | set(e['target'] for e in edges) # Convert to a data-storing object and initialize some values d = 3 if is_3d else 2 nodes = {n: {'velocity': [0.0] * d, 'force': [0.0] * d} for n in nodes} # Repeat n times (is there a more Pythonic way to do this?) for _ in repeat(None, iterations): # Add in Coulomb-esque node-node repulsive forces for node1, node2 in combinations(nodes.values(), 2): _coulomb(node1, node2, force_strength, max_distance) # And Hooke-esque edge spring forces for edge in edges: _hooke(nodes[edge['source']], nodes[edge['target']], force_strength * edge.get('size', 1), max_distance) # Move by resultant force for node in nodes.values(): # Constrain the force to the bounds specified by input parameter force = [_constrain(dampening * f, -max_velocity, max_velocity) for f in node['force']] # Update velocities and reset force node['velocity'] = [v + dv for v, dv in zip(node['velocity'], force)] node['force'] = [0] * d # Clean and return for node in nodes.values(): del node['force'] node['location'] = node['velocity'] del node['velocity'] # Even if it's 2D, let's specify three dimensions if not is_3d: node['location'] += [0.0] return nodes

def run(edges, iterations=1000, force_strength=5.0, dampening=0.01, max_velocity=2.0, max_distance=50, is_3d=True)

Runs a force-directed-layout algorithm on the input graph. iterations - Number of FDL iterations to run in coordinate generation force_strength - Strength of Coulomb and Hooke forces (edit this to scale the distance between nodes) dampening - Multiplier to reduce force applied to nodes max_velocity - Maximum distance a node can move in one step max_distance - The maximum distance considered for interactions

def run(edges, iterations=1000, force_strength=5.0, dampening=0.01, max_velocity=2.0, max_distance=50, is_3d=True): """ Runs a force-directed-layout algorithm on the input graph. iterations - Number of FDL iterations to run in coordinate generation force_strength - Strength of Coulomb and Hooke forces (edit this to scale the distance between nodes) dampening - Multiplier to reduce force applied to nodes max_velocity - Maximum distance a node can move in one step max_distance - The maximum distance considered for interactions """ # Get a list of node ids from the edge data nodes = set(e['source'] for e in edges) | set(e['target'] for e in edges) # Convert to a data-storing object and initialize some values d = 3 if is_3d else 2 nodes = {n: {'velocity': [0.0] * d, 'force': [0.0] * d} for n in nodes} # Repeat n times (is there a more Pythonic way to do this?) for _ in repeat(None, iterations): # Add in Coulomb-esque node-node repulsive forces for node1, node2 in combinations(nodes.values(), 2): _coulomb(node1, node2, force_strength, max_distance) # And Hooke-esque edge spring forces for edge in edges: _hooke(nodes[edge['source']], nodes[edge['target']], force_strength * edge.get('size', 1), max_distance) # Move by resultant force for node in nodes.values(): # Constrain the force to the bounds specified by input parameter force = [_constrain(dampening * f, -max_velocity, max_velocity) for f in node['force']] # Update velocities and reset force node['velocity'] = [v + dv for v, dv in zip(node['velocity'], force)] node['force'] = [0] * d # Clean and return for node in nodes.values(): del node['force'] node['location'] = node['velocity'] del node['velocity'] # Even if it's 2D, let's specify three dimensions if not is_3d: node['location'] += [0.0] return nodes

logger.debug("starting") assert pipeline assert steps_group logger.debug(f"retrieving {steps_group} steps from pipeline") if steps_group in pipeline: steps = pipeline[steps_group] if steps is None: logger.warn( f"{steps_group}: sequence has no elements. So it won't do " "anything.") logger.debug("done") return None steps_count = len(steps) logger.debug(f"{steps_count} steps found under {steps_group} in " "pipeline definition.") logger.debug("done") return steps else: logger.debug( f"pipeline doesn't have a {steps_group} collection. Add a " f"{steps_group}: sequence to the yaml if you want {steps_group} " "actually to do something.") logger.debug("done") return None

def get_pipeline_steps(pipeline, steps_group)

Get the steps attribute of module pipeline. If there is no steps sequence on the pipeline, return None. Guess you could theoretically want to run a pipeline with nothing in it.

def get_pipeline_steps(pipeline, steps_group): """ Get the steps attribute of module pipeline. If there is no steps sequence on the pipeline, return None. Guess you could theoretically want to run a pipeline with nothing in it. """ logger.debug("starting") assert pipeline assert steps_group logger.debug(f"retrieving {steps_group} steps from pipeline") if steps_group in pipeline: steps = pipeline[steps_group] if steps is None: logger.warn( f"{steps_group}: sequence has no elements. So it won't do " "anything.") logger.debug("done") return None steps_count = len(steps) logger.debug(f"{steps_count} steps found under {steps_group} in " "pipeline definition.") logger.debug("done") return steps else: logger.debug( f"pipeline doesn't have a {steps_group} collection. Add a " f"{steps_group}: sequence to the yaml if you want {steps_group} " "actually to do something.") logger.debug("done") return None

tag_representers = [PyString, SicString] yaml_loader = get_yaml_parser_safe() for representer in tag_representers: yaml_loader.register_class(representer) pipeline_definition = yaml_loader.load(file) return pipeline_definition

def get_pipeline_yaml(file)

Return pipeline yaml from open file object. Use specific custom representers to model the custom pypyr pipeline yaml format, to load in special literal types like py and sic strings. If looking to extend the pypyr pipeline syntax with special types, add these to the tag_representers list. Args: file: open file-like object. Returns: dict-like representation of loaded yaml.

def get_pipeline_yaml(file): """ Return pipeline yaml from open file object. Use specific custom representers to model the custom pypyr pipeline yaml format, to load in special literal types like py and sic strings. If looking to extend the pypyr pipeline syntax with special types, add these to the tag_representers list. Args: file: open file-like object. Returns: dict-like representation of loaded yaml. """ tag_representers = [PyString, SicString] yaml_loader = get_yaml_parser_safe() for representer in tag_representers: yaml_loader.register_class(representer) pipeline_definition = yaml_loader.load(file) return pipeline_definition

def partial(func, col, *args, **kwargs): def new_func(gdf): return func(gdf[col], *args, **kwargs) return new_func def make_statement(func, col): if isinstance(func, str): expr = '{}({})'.format(func, col) elif callable(func): expr = partial(func, col, *verb.args, **verb.kwargs) else: raise TypeError("{} is not a function".format(func)) return expr def func_name(func): if isinstance(func, str): return func try: return func.__name__ except AttributeError: return '' # Generate function names. They act as identifiers (postfixed # to the original columns) in the new_column names. if isinstance(verb.functions, (tuple, list)): names = (func_name(func) for func in verb.functions) names_and_functions = zip(names, verb.functions) else: names_and_functions = verb.functions.items() # Create statements for the expressions # and postfix identifiers columns = Selector.get(verb) # columns to act on postfixes = [] stmts = [] for name, func in names_and_functions: postfixes.append(name) for col in columns: stmts.append(make_statement(func, col)) if not stmts: stmts = columns # Names of the new columns # e.g col1_mean, col2_mean, col1_std, col2_std add_postfix = (isinstance(verb.functions, dict) or len(verb.functions) > 1) if add_postfix: fmt = '{}_{}'.format new_columns = [fmt(c, p) for p in postfixes for c in columns] else: new_columns = columns expressions = [Expression(stmt, col) for stmt, col in zip(stmts, new_columns)] return expressions, new_columns

def build_expressions(verb)

Build expressions for helper verbs Parameters ---------- verb : verb A verb with a *functions* attribute. Returns ------- out : tuple (List of Expressions, New columns). The expressions and the new columns in which the results of those expressions will be stored. Even when a result will stored in a column with an existing label, that column is still considered new, i.e An expression ``x='x+1'``, will create a new_column `x` to replace an old column `x`.

def build_expressions(verb): """ Build expressions for helper verbs Parameters ---------- verb : verb A verb with a *functions* attribute. Returns ------- out : tuple (List of Expressions, New columns). The expressions and the new columns in which the results of those expressions will be stored. Even when a result will stored in a column with an existing label, that column is still considered new, i.e An expression ``x='x+1'``, will create a new_column `x` to replace an old column `x`. """ def partial(func, col, *args, **kwargs): def new_func(gdf): return func(gdf[col], *args, **kwargs) return new_func def make_statement(func, col): if isinstance(func, str): expr = '{}({})'.format(func, col) elif callable(func): expr = partial(func, col, *verb.args, **verb.kwargs) else: raise TypeError("{} is not a function".format(func)) return expr def func_name(func): if isinstance(func, str): return func try: return func.__name__ except AttributeError: return '' # Generate function names. They act as identifiers (postfixed # to the original columns) in the new_column names. if isinstance(verb.functions, (tuple, list)): names = (func_name(func) for func in verb.functions) names_and_functions = zip(names, verb.functions) else: names_and_functions = verb.functions.items() # Create statements for the expressions # and postfix identifiers columns = Selector.get(verb) # columns to act on postfixes = [] stmts = [] for name, func in names_and_functions: postfixes.append(name) for col in columns: stmts.append(make_statement(func, col)) if not stmts: stmts = columns # Names of the new columns # e.g col1_mean, col2_mean, col1_std, col2_std add_postfix = (isinstance(verb.functions, dict) or len(verb.functions) > 1) if add_postfix: fmt = '{}_{}'.format new_columns = [fmt(c, p) for p in postfixes for c in columns] else: new_columns = columns expressions = [Expression(stmt, col) for stmt, col in zip(stmts, new_columns)] return expressions, new_columns

# Note: There's an experimental JSON encoder floating around in # pandas land that hasn't made it into the main branch. This # function should be revisited if it ever does. if not pd: raise LoadError('pandas could not be imported') if not hasattr(data, 'index'): raise ValueError('Please load a Pandas object.') if name: vega_data = cls(name=name, **kwargs) else: vega_data = cls(name='table', **kwargs) pd_obj = data.copy() if columns: pd_obj = data[columns] if key_on != 'idx': pd_obj.index = data[key_on] if records: # The worst vega_data.values = json.loads(pd_obj.to_json(orient='records')) return vega_data vega_data.values = [] if isinstance(pd_obj, pd.Series): data_key = data.name or series_key for i, v in pd_obj.iteritems(): value = {} value['idx'] = cls.serialize(i) value['col'] = data_key value['val'] = cls.serialize(v) vega_data.values.append(value) elif isinstance(pd_obj, pd.DataFrame): # We have to explicitly convert the column names to strings # because the json serializer doesn't allow for integer keys. for i, row in pd_obj.iterrows(): for num, (k, v) in enumerate(row.iteritems()): value = {} value['idx'] = cls.serialize(i) value['col'] = cls.serialize(k) value['val'] = cls.serialize(v) if grouped: value['group'] = num vega_data.values.append(value) else: raise ValueError('cannot load from data type ' + type(pd_obj).__name__) return vega_data

def from_pandas(cls, data, columns=None, key_on='idx', name=None, series_key='data', grouped=False, records=False, **kwargs)

Load values from a pandas ``Series`` or ``DataFrame`` object Parameters ---------- data : pandas ``Series`` or ``DataFrame`` Pandas object to import data from. columns: list, default None DataFrame columns to convert to Data. Keys default to col names. If columns are given and on_index is False, x-axis data will default to the first column. key_on: string, default 'index' Value to key on for x-axis data. Defaults to index. name : string, default None Applies to the ``name`` attribute of the generated class. If ``None`` (default), then the ``name`` attribute of ``pd_obj`` is used if it exists, or ``'table'`` if it doesn't. series_key : string, default 'data' Applies only to ``Series``. If ``None`` (default), then defaults to data.name. For example, if ``series_key`` is ``'x'``, then the entries of the ``values`` list will be ``{'idx': ..., 'col': 'x', 'val': ...}``. grouped: boolean, default False Pass true for an extra grouping parameter records: boolean, defaule False Requires Pandas 0.12 or greater. Writes the Pandas DataFrame using the df.to_json(orient='records') formatting. **kwargs : dict Additional arguments passed to the :class:`Data` constructor.

def from_pandas(cls, data, columns=None, key_on='idx', name=None, series_key='data', grouped=False, records=False, **kwargs): """ Load values from a pandas ``Series`` or ``DataFrame`` object Parameters ---------- data : pandas ``Series`` or ``DataFrame`` Pandas object to import data from. columns: list, default None DataFrame columns to convert to Data. Keys default to col names. If columns are given and on_index is False, x-axis data will default to the first column. key_on: string, default 'index' Value to key on for x-axis data. Defaults to index. name : string, default None Applies to the ``name`` attribute of the generated class. If ``None`` (default), then the ``name`` attribute of ``pd_obj`` is used if it exists, or ``'table'`` if it doesn't. series_key : string, default 'data' Applies only to ``Series``. If ``None`` (default), then defaults to data.name. For example, if ``series_key`` is ``'x'``, then the entries of the ``values`` list will be ``{'idx': ..., 'col': 'x', 'val': ...}``. grouped: boolean, default False Pass true for an extra grouping parameter records: boolean, defaule False Requires Pandas 0.12 or greater. Writes the Pandas DataFrame using the df.to_json(orient='records') formatting. **kwargs : dict Additional arguments passed to the :class:`Data` constructor. """ # Note: There's an experimental JSON encoder floating around in # pandas land that hasn't made it into the main branch. This # function should be revisited if it ever does. if not pd: raise LoadError('pandas could not be imported') if not hasattr(data, 'index'): raise ValueError('Please load a Pandas object.') if name: vega_data = cls(name=name, **kwargs) else: vega_data = cls(name='table', **kwargs) pd_obj = data.copy() if columns: pd_obj = data[columns] if key_on != 'idx': pd_obj.index = data[key_on] if records: # The worst vega_data.values = json.loads(pd_obj.to_json(orient='records')) return vega_data vega_data.values = [] if isinstance(pd_obj, pd.Series): data_key = data.name or series_key for i, v in pd_obj.iteritems(): value = {} value['idx'] = cls.serialize(i) value['col'] = data_key value['val'] = cls.serialize(v) vega_data.values.append(value) elif isinstance(pd_obj, pd.DataFrame): # We have to explicitly convert the column names to strings # because the json serializer doesn't allow for integer keys. for i, row in pd_obj.iterrows(): for num, (k, v) in enumerate(row.iteritems()): value = {} value['idx'] = cls.serialize(i) value['col'] = cls.serialize(k) value['val'] = cls.serialize(v) if grouped: value['group'] = num vega_data.values.append(value) else: raise ValueError('cannot load from data type ' + type(pd_obj).__name__) return vega_data

if not np: raise LoadError('numpy could not be imported') _assert_is_type('numpy object', np_obj, np.ndarray) # Integer index if none is provided index = index or range(np_obj.shape[0]) # Explicitly map dict-keys to strings for JSON serializer. columns = list(map(str, columns)) index_key = index_key or cls._default_index_key if len(index) != np_obj.shape[0]: raise LoadError( 'length of index must be equal to number of rows of array') elif len(columns) != np_obj.shape[1]: raise LoadError( 'length of columns must be equal to number of columns of ' 'array') data = cls(name=name, **kwargs) data.values = [ dict([(index_key, cls.serialize(idx))] + [(col, x) for col, x in zip(columns, row)]) for idx, row in zip(index, np_obj.tolist())] return data

def from_numpy(cls, np_obj, name, columns, index=None, index_key=None, **kwargs)

Load values from a numpy array Parameters ---------- np_obj : numpy.ndarray numpy array to load data from name : string ``name`` field for the data columns : iterable Sequence of column names, from left to right. Must have same length as the number of columns of ``np_obj``. index : iterable, default None Sequence of indices from top to bottom. If ``None`` (default), then the indices are integers starting at 0. Must have same length as the number of rows of ``np_obj``. index_key : string, default None Key to use for the index. If ``None`` (default), ``idx`` is used. **kwargs : dict Additional arguments passed to the :class:`Data` constructor Notes ----- The individual elements of ``np_obj``, ``columns``, and ``index`` must return valid values from :func:`Data.serialize`.

def from_numpy(cls, np_obj, name, columns, index=None, index_key=None, **kwargs): """ Load values from a numpy array Parameters ---------- np_obj : numpy.ndarray numpy array to load data from name : string ``name`` field for the data columns : iterable Sequence of column names, from left to right. Must have same length as the number of columns of ``np_obj``. index : iterable, default None Sequence of indices from top to bottom. If ``None`` (default), then the indices are integers starting at 0. Must have same length as the number of rows of ``np_obj``. index_key : string, default None Key to use for the index. If ``None`` (default), ``idx`` is used. **kwargs : dict Additional arguments passed to the :class:`Data` constructor Notes ----- The individual elements of ``np_obj``, ``columns``, and ``index`` must return valid values from :func:`Data.serialize`. """ if not np: raise LoadError('numpy could not be imported') _assert_is_type('numpy object', np_obj, np.ndarray) # Integer index if none is provided index = index or range(np_obj.shape[0]) # Explicitly map dict-keys to strings for JSON serializer. columns = list(map(str, columns)) index_key = index_key or cls._default_index_key if len(index) != np_obj.shape[0]: raise LoadError( 'length of index must be equal to number of rows of array') elif len(columns) != np_obj.shape[1]: raise LoadError( 'length of columns must be equal to number of columns of ' 'array') data = cls(name=name, **kwargs) data.values = [ dict([(index_key, cls.serialize(idx))] + [(col, x) for col, x in zip(columns, row)]) for idx, row in zip(index, np_obj.tolist())] return data

if not name: name = 'table' cls.raw_data = data # Tuples if isinstance(data, tuple): values = [{"x": x[0], "y": x[1]} for x in data] # Lists elif isinstance(data, list): values = [{"x": x, "y": y} for x, y in zip(range(len(data) + 1), data)] # Dicts elif isinstance(data, dict) or isinstance(data, pd.Series): values = [{"x": x, "y": y} for x, y in sorted(data.items())] # Dataframes elif isinstance(data, pd.DataFrame): if len(columns) > 1 and use_index: raise ValueError('If using index as x-axis, len(columns)' 'cannot be > 1') if use_index or len(columns) == 1: values = [{"x": cls.serialize(x[0]), "y": cls.serialize(x[1][columns[0]])} for x in data.iterrows()] else: values = [{"x": cls.serialize(x[1][columns[0]]), "y": cls.serialize(x[1][columns[1]])} for x in data.iterrows()] # NumPy arrays elif isinstance(data, np.ndarray): values = cls._numpy_to_values(data) else: raise TypeError('unknown data type %s' % type(data)) return cls(name, values=values)

def keypairs(cls, data, columns=None, use_index=False, name=None)

This will format the data as Key: Value pairs, rather than the idx/col/val style. This is useful for some transforms, and to key choropleth map data Standard Data Types: List: [0, 10, 20, 30, 40] Paired Tuples: ((0, 1), (0, 2), (0, 3)) Dict: {'A': 10, 'B': 20, 'C': 30, 'D': 40, 'E': 50} Plus Pandas DataFrame and Series, and Numpy ndarray Parameters ---------- data: List, Tuple, Dict, Pandas Series/DataFrame, Numpy ndarray columns: list, default None If passing Pandas DataFrame, you must pass at least one column name.If one column is passed, x-values will default to the index values.If two column names are passed, x-values are columns[0], y-values columns[1]. use_index: boolean, default False Use the DataFrame index for your x-values

def keypairs(cls, data, columns=None, use_index=False, name=None): """ This will format the data as Key: Value pairs, rather than the idx/col/val style. This is useful for some transforms, and to key choropleth map data Standard Data Types: List: [0, 10, 20, 30, 40] Paired Tuples: ((0, 1), (0, 2), (0, 3)) Dict: {'A': 10, 'B': 20, 'C': 30, 'D': 40, 'E': 50} Plus Pandas DataFrame and Series, and Numpy ndarray Parameters ---------- data: List, Tuple, Dict, Pandas Series/DataFrame, Numpy ndarray columns: list, default None If passing Pandas DataFrame, you must pass at least one column name.If one column is passed, x-values will default to the index values.If two column names are passed, x-values are columns[0], y-values columns[1]. use_index: boolean, default False Use the DataFrame index for your x-values """ if not name: name = 'table' cls.raw_data = data # Tuples if isinstance(data, tuple): values = [{"x": x[0], "y": x[1]} for x in data] # Lists elif isinstance(data, list): values = [{"x": x, "y": y} for x, y in zip(range(len(data) + 1), data)] # Dicts elif isinstance(data, dict) or isinstance(data, pd.Series): values = [{"x": x, "y": y} for x, y in sorted(data.items())] # Dataframes elif isinstance(data, pd.DataFrame): if len(columns) > 1 and use_index: raise ValueError('If using index as x-axis, len(columns)' 'cannot be > 1') if use_index or len(columns) == 1: values = [{"x": cls.serialize(x[0]), "y": cls.serialize(x[1][columns[0]])} for x in data.iterrows()] else: values = [{"x": cls.serialize(x[1][columns[0]]), "y": cls.serialize(x[1][columns[1]])} for x in data.iterrows()] # NumPy arrays elif isinstance(data, np.ndarray): values = cls._numpy_to_values(data) else: raise TypeError('unknown data type %s' % type(data)) return cls(name, values=values)

'''Convert a NumPy array to values attribute''' def to_list_no_index(xvals, yvals): return [{"x": x, "y": np.asscalar(y)} for x, y in zip(xvals, yvals)] if len(data.shape) == 1 or data.shape[1] == 1: xvals = range(data.shape[0] + 1) values = to_list_no_index(xvals, data) elif len(data.shape) == 2: if data.shape[1] == 2: # NumPy arrays and matrices have different iteration rules. if isinstance(data, np.matrix): xidx = (0, 0) yidx = (0, 1) else: xidx = 0 yidx = 1 xvals = [np.asscalar(row[xidx]) for row in data] yvals = [np.asscalar(row[yidx]) for row in data] values = [{"x": x, "y": y} for x, y in zip(xvals, yvals)] else: raise ValueError('arrays with > 2 columns not supported') else: raise ValueError('invalid dimensions for ndarray') return values

def _numpy_to_values(data)

Convert a NumPy array to values attribute

def _numpy_to_values(data): """ Convert a NumPy array to values attribute """ '''Convert a NumPy array to values attribute''' def to_list_no_index(xvals, yvals): return [{"x": x, "y": np.asscalar(y)} for x, y in zip(xvals, yvals)] if len(data.shape) == 1 or data.shape[1] == 1: xvals = range(data.shape[0] + 1) values = to_list_no_index(xvals, data) elif len(data.shape) == 2: if data.shape[1] == 2: # NumPy arrays and matrices have different iteration rules. if isinstance(data, np.matrix): xidx = (0, 0) yidx = (0, 1) else: xidx = 0 yidx = 1 xvals = [np.asscalar(row[xidx]) for row in data] yvals = [np.asscalar(row[yidx]) for row in data] values = [{"x": x, "y": y} for x, y in zip(xvals, yvals)] else: raise ValueError('arrays with > 2 columns not supported') else: raise ValueError('invalid dimensions for ndarray') return values

retval = tuple() for val in self.VALUES: retval += (getattr(self, val),) return retval

def get_value_tuple(self)

Returns a tuple of the color's values (in order). For example, an LabColor object will return (lab_l, lab_a, lab_b), where each member of the tuple is the float value for said variable.

def get_value_tuple(self): """ Returns a tuple of the color's values (in order). For example, an LabColor object will return (lab_l, lab_a, lab_b), where each member of the tuple is the float value for said variable. """ retval = tuple() for val in self.VALUES: retval += (getattr(self, val),) return retval

# This holds the obect's spectral data, and will be passed to # numpy.array() to create a numpy array (matrix) for the matrix math # that will be done during the conversion to XYZ. values = [] # Use the required value list to build this dynamically. Default to # 0.0, since that ultimately won't affect the outcome due to the math # involved. for val in self.VALUES: values.append(getattr(self, val, 0.0)) # Create and the actual numpy array/matrix from the spectral list. color_array = numpy.array([values]) return color_array

def get_numpy_array(self)

Dump this color into NumPy array.

def get_numpy_array(self): """ Dump this color into NumPy array. """ # This holds the obect's spectral data, and will be passed to # numpy.array() to create a numpy array (matrix) for the matrix math # that will be done during the conversion to XYZ. values = [] # Use the required value list to build this dynamically. Default to # 0.0, since that ultimately won't affect the outcome due to the math # involved. for val in self.VALUES: values.append(getattr(self, val, 0.0)) # Create and the actual numpy array/matrix from the spectral list. color_array = numpy.array([values]) return color_array

blue_density = ansi_density(color, ANSI_STATUS_T_BLUE) green_density = ansi_density(color, ANSI_STATUS_T_GREEN) red_density = ansi_density(color, ANSI_STATUS_T_RED) densities = [blue_density, green_density, red_density] min_density = min(densities) max_density = max(densities) density_range = max_density - min_density # See comments in density_standards.py for VISUAL_DENSITY_THRESH to # understand what this is doing. if density_range <= VISUAL_DENSITY_THRESH: return ansi_density(color, ISO_VISUAL) elif blue_density > green_density and blue_density > red_density: return blue_density elif green_density > blue_density and green_density > red_density: return green_density else: return red_density

def auto_density(color)

Given a SpectralColor, automatically choose the correct ANSI T filter. Returns a tuple with a string representation of the filter the calculated density. :param SpectralColor color: The SpectralColor object to calculate density for. :rtype: float :returns: The density value, with the filter selected automatically.

def auto_density(color): """ Given a SpectralColor, automatically choose the correct ANSI T filter. Returns a tuple with a string representation of the filter the calculated density. :param SpectralColor color: The SpectralColor object to calculate density for. :rtype: float :returns: The density value, with the filter selected automatically. """ blue_density = ansi_density(color, ANSI_STATUS_T_BLUE) green_density = ansi_density(color, ANSI_STATUS_T_GREEN) red_density = ansi_density(color, ANSI_STATUS_T_RED) densities = [blue_density, green_density, red_density] min_density = min(densities) max_density = max(densities) density_range = max_density - min_density # See comments in density_standards.py for VISUAL_DENSITY_THRESH to # understand what this is doing. if density_range <= VISUAL_DENSITY_THRESH: return ansi_density(color, ISO_VISUAL) elif blue_density > green_density and blue_density > red_density: return blue_density elif green_density > blue_density and green_density > red_density: return green_density else: return red_density

color1_vector = _get_lab_color1_vector(color1) color2_matrix = _get_lab_color2_matrix(color2) delta_e = color_diff_matrix.delta_e_cie1976(color1_vector, color2_matrix)[0] return numpy.asscalar(delta_e)

def delta_e_cie1976(color1, color2)

Calculates the Delta E (CIE1976) of two colors.

def delta_e_cie1976(color1, color2): """ Calculates the Delta E (CIE1976) of two colors. """ color1_vector = _get_lab_color1_vector(color1) color2_matrix = _get_lab_color2_matrix(color2) delta_e = color_diff_matrix.delta_e_cie1976(color1_vector, color2_matrix)[0] return numpy.asscalar(delta_e)

def decorator(f): f.start_type = start_type f.target_type = target_type _conversion_manager.add_type_conversion(start_type, target_type, f) return f return decorator

def color_conversion_function(start_type, target_type)

Decorator to indicate a function that performs a conversion from one color space to another. This decorator will return the original function unmodified, however it will be registered in the _conversion_manager so it can be used to perform color space transformations between color spaces that do not have direct conversion functions (e.g., Luv to CMYK). Note: For a conversion to/from RGB supply the BaseRGBColor class. :param start_type: Starting color space type :param target_type: Target color space type

def color_conversion_function(start_type, target_type): """ Decorator to indicate a function that performs a conversion from one color space to another. This decorator will return the original function unmodified, however it will be registered in the _conversion_manager so it can be used to perform color space transformations between color spaces that do not have direct conversion functions (e.g., Luv to CMYK). Note: For a conversion to/from RGB supply the BaseRGBColor class. :param start_type: Starting color space type :param target_type: Target color space type """ def decorator(f): f.start_type = start_type f.target_type = target_type _conversion_manager.add_type_conversion(start_type, target_type, f) return f return decorator

rgb = self.xyz_to_rgb(xyz) logger.debug('RGB: {}'.format(rgb)) rgb_w = self.xyz_to_rgb(xyz_w) logger.debug('RGB_W: {}'.format(rgb_w)) y_w = xyz_w[1] y_b = xyz_b[1] h_rgb = 3 * rgb_w / (rgb_w.sum()) logger.debug('H_RGB: {}'.format(h_rgb)) # Chromatic adaptation factors if not discount_illuminant: f_rgb = (1 + (l_a ** (1 / 3)) + h_rgb) / (1 + (l_a ** (1 / 3)) + (1 / h_rgb)) else: f_rgb = numpy.ones(numpy.shape(h_rgb)) logger.debug('F_RGB: {}'.format(f_rgb)) # Adaptation factor if helson_judd: d_rgb = self._f_n((y_b / y_w) * f_l * f_rgb[1]) - self._f_n((y_b / y_w) * f_l * f_rgb) assert d_rgb[1] == 0 else: d_rgb = numpy.zeros(numpy.shape(f_rgb)) logger.debug('D_RGB: {}'.format(d_rgb)) # Cone bleaching factors rgb_b = (10 ** 7) / ((10 ** 7) + 5 * l_a * (rgb_w / 100)) logger.debug('B_RGB: {}'.format(rgb_b)) if xyz_p is not None and p is not None: logger.debug('Account for simultaneous chromatic contrast') rgb_p = self.xyz_to_rgb(xyz_p) rgb_w = self.adjust_white_for_scc(rgb_p, rgb_b, rgb_w, p) # Adapt rgb using modified rgb_a = 1 + rgb_b * (self._f_n(f_l * f_rgb * rgb / rgb_w) + d_rgb) logger.debug('RGB_A: {}'.format(rgb_a)) return rgb_a

def _adaptation(self, f_l, l_a, xyz, xyz_w, xyz_b, xyz_p=None, p=None, helson_judd=False, discount_illuminant=True)

:param f_l: Luminance adaptation factor :param l_a: Adapting luminance :param xyz: Stimulus color in XYZ :param xyz_w: Reference white color in XYZ :param xyz_b: Background color in XYZ :param xyz_p: Proxima field color in XYZ :param p: Simultaneous contrast/assimilation parameter.

def _adaptation(self, f_l, l_a, xyz, xyz_w, xyz_b, xyz_p=None, p=None, helson_judd=False, discount_illuminant=True): """ :param f_l: Luminance adaptation factor :param l_a: Adapting luminance :param xyz: Stimulus color in XYZ :param xyz_w: Reference white color in XYZ :param xyz_b: Background color in XYZ :param xyz_p: Proxima field color in XYZ :param p: Simultaneous contrast/assimilation parameter. """ rgb = self.xyz_to_rgb(xyz) logger.debug('RGB: {}'.format(rgb)) rgb_w = self.xyz_to_rgb(xyz_w) logger.debug('RGB_W: {}'.format(rgb_w)) y_w = xyz_w[1] y_b = xyz_b[1] h_rgb = 3 * rgb_w / (rgb_w.sum()) logger.debug('H_RGB: {}'.format(h_rgb)) # Chromatic adaptation factors if not discount_illuminant: f_rgb = (1 + (l_a ** (1 / 3)) + h_rgb) / (1 + (l_a ** (1 / 3)) + (1 / h_rgb)) else: f_rgb = numpy.ones(numpy.shape(h_rgb)) logger.debug('F_RGB: {}'.format(f_rgb)) # Adaptation factor if helson_judd: d_rgb = self._f_n((y_b / y_w) * f_l * f_rgb[1]) - self._f_n((y_b / y_w) * f_l * f_rgb) assert d_rgb[1] == 0 else: d_rgb = numpy.zeros(numpy.shape(f_rgb)) logger.debug('D_RGB: {}'.format(d_rgb)) # Cone bleaching factors rgb_b = (10 ** 7) / ((10 ** 7) + 5 * l_a * (rgb_w / 100)) logger.debug('B_RGB: {}'.format(rgb_b)) if xyz_p is not None and p is not None: logger.debug('Account for simultaneous chromatic contrast') rgb_p = self.xyz_to_rgb(xyz_p) rgb_w = self.adjust_white_for_scc(rgb_p, rgb_b, rgb_w, p) # Adapt rgb using modified rgb_a = 1 + rgb_b * (self._f_n(f_l * f_rgb * rgb / rgb_w) + d_rgb) logger.debug('RGB_A: {}'.format(rgb_a)) return rgb_a

x_e = 0.3320 y_e = 0.1858 n = ((x / (x + z + z)) - x_e) / ((y / (x + z + z)) - y_e) a_0 = -949.86315 a_1 = 6253.80338 a_2 = 28.70599 a_3 = 0.00004 t_1 = 0.92159 t_2 = 0.20039 t_3 = 0.07125 cct = a_0 + a_1 * numpy.exp(-n / t_1) + a_2 * numpy.exp(-n / t_2) + a_3 * numpy.exp(-n / t_3) return cct

def _get_cct(x, y, z)

Reference Hernandez-Andres, J., Lee, R. L., & Romero, J. (1999). Calculating correlated color temperatures across the entire gamut of daylight and skylight chromaticities. Applied Optics, 38(27), 5703-5709.

def _get_cct(x, y, z): """ Reference Hernandez-Andres, J., Lee, R. L., & Romero, J. (1999). Calculating correlated color temperatures across the entire gamut of daylight and skylight chromaticities. Applied Optics, 38(27), 5703-5709. """ x_e = 0.3320 y_e = 0.1858 n = ((x / (x + z + z)) - x_e) / ((y / (x + z + z)) - y_e) a_0 = -949.86315 a_1 = 6253.80338 a_2 = 28.70599 a_3 = 0.00004 t_1 = 0.92159 t_2 = 0.20039 t_3 = 0.07125 cct = a_0 + a_1 * numpy.exp(-n / t_1) + a_2 * numpy.exp(-n / t_2) + a_3 * numpy.exp(-n / t_3) return cct

# Transform input colors to cone responses rgb = self._xyz_to_rgb(xyz) logger.debug("RGB: {}".format(rgb)) rgb_b = self._xyz_to_rgb(self._xyz_b) rgb_w = self._xyz_to_rgb(xyz_w) rgb_w = Hunt.adjust_white_for_scc(rgb, rgb_b, rgb_w, self._p) logger.debug("RGB_W: {}".format(rgb_w)) # Compute adapted tristimulus-responses rgb_c = self._white_adaption(rgb, rgb_w, d) logger.debug("RGB_C: {}".format(rgb_c)) rgb_cw = self._white_adaption(rgb_w, rgb_w, d) logger.debug("RGB_CW: {}".format(rgb_cw)) # Convert adapted tristimulus-responses to Hunt-Pointer-Estevez fundamentals rgb_p = self._compute_hunt_pointer_estevez_fundamentals(rgb_c) logger.debug("RGB': {}".format(rgb_p)) rgb_wp = self._compute_hunt_pointer_estevez_fundamentals(rgb_cw) logger.debug("RGB'_W: {}".format(rgb_wp)) # Compute post-adaptation non-linearities rgb_ap = self._compute_nonlinearities(f_l, rgb_p) rgb_awp = self._compute_nonlinearities(f_l, rgb_wp) return rgb_ap, rgb_awp

def _compute_adaptation(self, xyz, xyz_w, f_l, d)

Modified adaptation procedure incorporating simultaneous chromatic contrast from Hunt model. :param xyz: Stimulus XYZ. :param xyz_w: Reference white XYZ. :param f_l: Luminance adaptation factor :param d: Degree of adaptation. :return: Tuple of adapted rgb and rgb_w arrays.

def _compute_adaptation(self, xyz, xyz_w, f_l, d): """ Modified adaptation procedure incorporating simultaneous chromatic contrast from Hunt model. :param xyz: Stimulus XYZ. :param xyz_w: Reference white XYZ. :param f_l: Luminance adaptation factor :param d: Degree of adaptation. :return: Tuple of adapted rgb and rgb_w arrays. """ # Transform input colors to cone responses rgb = self._xyz_to_rgb(xyz) logger.debug("RGB: {}".format(rgb)) rgb_b = self._xyz_to_rgb(self._xyz_b) rgb_w = self._xyz_to_rgb(xyz_w) rgb_w = Hunt.adjust_white_for_scc(rgb, rgb_b, rgb_w, self._p) logger.debug("RGB_W: {}".format(rgb_w)) # Compute adapted tristimulus-responses rgb_c = self._white_adaption(rgb, rgb_w, d) logger.debug("RGB_C: {}".format(rgb_c)) rgb_cw = self._white_adaption(rgb_w, rgb_w, d) logger.debug("RGB_CW: {}".format(rgb_cw)) # Convert adapted tristimulus-responses to Hunt-Pointer-Estevez fundamentals rgb_p = self._compute_hunt_pointer_estevez_fundamentals(rgb_c) logger.debug("RGB': {}".format(rgb_p)) rgb_wp = self._compute_hunt_pointer_estevez_fundamentals(rgb_cw) logger.debug("RGB'_W: {}".format(rgb_wp)) # Compute post-adaptation non-linearities rgb_ap = self._compute_nonlinearities(f_l, rgb_p) rgb_awp = self._compute_nonlinearities(f_l, rgb_wp) return rgb_ap, rgb_awp

year = super(BuildableDayArchiveView, self).get_year() month = super(BuildableDayArchiveView, self).get_month() day = super(BuildableDayArchiveView, self).get_day() fmt = self.get_day_format() dt = date(int(year), int(month), int(day)) return dt.strftime(fmt)

def get_day(self)

Return the day from the database in the format expected by the URL.

def get_day(self): """ Return the day from the database in the format expected by the URL. """ year = super(BuildableDayArchiveView, self).get_year() month = super(BuildableDayArchiveView, self).get_month() day = super(BuildableDayArchiveView, self).get_day() fmt = self.get_day_format() dt = date(int(year), int(month), int(day)) return dt.strftime(fmt)

if isinstance(p, str): p = string(p) return regex(r'\s*') >> p << regex(r'\s*')

def lexeme(p)

From a parser (or string), make a parser that consumes whitespace on either side.

def lexeme(p): """ From a parser (or string), make a parser that consumes whitespace on either side. """ if isinstance(p, str): p = string(p) return regex(r'\s*') >> p << regex(r'\s*')

with open(schemafile) as f: return cls(json.load(f))

def from_schemafile(cls, schemafile)

Create a Flatson instance from a schemafile

def from_schemafile(cls, schemafile): """ Create a Flatson instance from a schemafile """ with open(schemafile) as f: return cls(json.load(f))

if self._conn.status == psycopg2.extensions.STATUS_BEGIN: return self.READY return self._conn.status

def _status(self)

Return the current connection status as an integer value. The status should match one of the following constants: - queries.Session.INTRANS: Connection established, in transaction - queries.Session.PREPARED: Prepared for second phase of transaction - queries.Session.READY: Connected, no active transaction :rtype: int

def _status(self): """ Return the current connection status as an integer value. The status should match one of the following constants: - queries.Session.INTRANS: Connection established, in transaction - queries.Session.PREPARED: Prepared for second phase of transaction - queries.Session.READY: Connected, no active transaction :rtype: int """ if self._conn.status == psycopg2.extensions.STATUS_BEGIN: return self.READY return self._conn.status

if not self.cursor.rowcount: return [] self.cursor.scroll(0, 'absolute') return self.cursor.fetchall()

def items(self)

Return all of the rows that are in the result set. :rtype: list

def items(self): """ Return all of the rows that are in the result set. :rtype: list """ if not self.cursor.rowcount: return [] self.cursor.scroll(0, 'absolute') return self.cursor.fetchall()

if self.term.is_a_tty: return self.term.width // self.hint_width return 1

def num_columns(self)

Number of columns displayed.

def num_columns(self): """ Number of columns displayed. """ if self.term.is_a_tty: return self.term.width // self.hint_width return 1

path_processor = ((lambda x : x) if path_prefix is None else get_rp_stripper(path_prefix)) reports = [] for result in bads: if len(result) == 3: depended_lib, depending_lib, missing_archs = result reports.append("{0} needs {1} {2} missing from {3}".format( path_processor(depending_lib), 'archs' if len(missing_archs) > 1 else 'arch', ', '.join(sorted(missing_archs)), path_processor(depended_lib))) elif len(result) == 2: depending_lib, missing_archs = result reports.append("Required {0} {1} missing from {2}".format( 'archs' if len(missing_archs) > 1 else 'arch', ', '.join(sorted(missing_archs)), path_processor(depending_lib))) else: raise ValueError('Report tuple should be length 2 or 3') return '\n'.join(sorted(reports))

def bads_report(bads, path_prefix=None)

Return a nice report of bad architectures in `bads` Parameters ---------- bads : set set of length 2 or 3 tuples. A length 2 tuple is of form ``(depending_lib, missing_archs)`` meaning that an arch in `require_archs` was missing from ``depending_lib``. A length 3 tuple is of form ``(depended_lib, depending_lib, missing_archs)`` where ``depended_lib`` is the filename of the library depended on, ``depending_lib`` is the library depending on ``depending_lib`` and ``missing_archs`` is a set of missing architecture strings giving architectures present in ``depending_lib`` and missing in ``depended_lib``. An empty set means all architectures were present as required. path_prefix : None or str, optional Path prefix to strip from ``depended_lib`` and ``depending_lib``. None means do not strip anything. Returns ------- report : str A nice report for printing

def bads_report(bads, path_prefix=None): """ Return a nice report of bad architectures in `bads` Parameters ---------- bads : set set of length 2 or 3 tuples. A length 2 tuple is of form ``(depending_lib, missing_archs)`` meaning that an arch in `require_archs` was missing from ``depending_lib``. A length 3 tuple is of form ``(depended_lib, depending_lib, missing_archs)`` where ``depended_lib`` is the filename of the library depended on, ``depending_lib`` is the library depending on ``depending_lib`` and ``missing_archs`` is a set of missing architecture strings giving architectures present in ``depending_lib`` and missing in ``depended_lib``. An empty set means all architectures were present as required. path_prefix : None or str, optional Path prefix to strip from ``depended_lib`` and ``depending_lib``. None means do not strip anything. Returns ------- report : str A nice report for printing """ path_processor = ((lambda x : x) if path_prefix is None else get_rp_stripper(path_prefix)) reports = [] for result in bads: if len(result) == 3: depended_lib, depending_lib, missing_archs = result reports.append("{0} needs {1} {2} missing from {3}".format( path_processor(depending_lib), 'archs' if len(missing_archs) > 1 else 'arch', ', '.join(sorted(missing_archs)), path_processor(depended_lib))) elif len(result) == 2: depending_lib, missing_archs = result reports.append("Required {0} {1} missing from {2}".format( 'archs' if len(missing_archs) > 1 else 'arch', ', '.join(sorted(missing_archs)), path_processor(depending_lib))) else: raise ValueError('Report tuple should be length 2 or 3') return '\n'.join(sorted(reports))

if not lib_path.startswith('@rpath/'): return lib_path lib_rpath = lib_path.split('/', 1)[1] for rpath in rpaths: rpath_lib = realpath(pjoin(rpath, lib_rpath)) if os.path.exists(rpath_lib): return rpath_lib warnings.warn( "Couldn't find {0} on paths:\n\t{1}".format( lib_path, '\n\t'.join(realpath(path) for path in rpaths), ) ) return lib_path

def resolve_rpath(lib_path, rpaths)

Return `lib_path` with its `@rpath` resolved If the `lib_path` doesn't have `@rpath` then it's returned as is. If `lib_path` has `@rpath` then returns the first `rpaths`/`lib_path` combination found. If the library can't be found in `rpaths` then a detailed warning is printed and `lib_path` is returned as is. Parameters ---------- lib_path : str The path to a library file, which may or may not start with `@rpath`. rpaths : sequence of str A sequence of search paths, usually gotten from a call to `get_rpaths`. Returns ------- lib_path : str A str with the resolved libraries realpath.

def resolve_rpath(lib_path, rpaths): """ Return `lib_path` with its `@rpath` resolved If the `lib_path` doesn't have `@rpath` then it's returned as is. If `lib_path` has `@rpath` then returns the first `rpaths`/`lib_path` combination found. If the library can't be found in `rpaths` then a detailed warning is printed and `lib_path` is returned as is. Parameters ---------- lib_path : str The path to a library file, which may or may not start with `@rpath`. rpaths : sequence of str A sequence of search paths, usually gotten from a call to `get_rpaths`. Returns ------- lib_path : str A str with the resolved libraries realpath. """ if not lib_path.startswith('@rpath/'): return lib_path lib_rpath = lib_path.split('/', 1)[1] for rpath in rpaths: rpath_lib = realpath(pjoin(rpath, lib_rpath)) if os.path.exists(rpath_lib): return rpath_lib warnings.warn( "Couldn't find {0} on paths:\n\t{1}".format( lib_path, '\n\t'.join(realpath(path) for path in rpaths), ) ) return lib_path

N = community.shape[0] C = community.shape[1] T = P = np.zeros([N, N]) for t in range(len(community[0, :])): for i in range(len(community[:, 0])): for j in range(len(community[:, 0])): if i == j: continue # T_ij indicates the number of times that i and j are assigned to the same community across time if community[i][t] == community[j][t]: T[i, j] += 1 # module allegiance matrix, probability that ij were assigned to the same community P = (1/C)*T return P

def allegiance(community)

Computes the allegiance matrix with values representing the probability that nodes i and j were assigned to the same community by time-varying clustering methods. parameters ---------- community : array array of community assignment of size node,time returns ------- P : array module allegiance matrix, with P_ij probability that area i and j are in the same community Reference: ---------- Bassett, et al. (2013) “Robust detection of dynamic community structure in networks”, Chaos, 23, 1

def allegiance(community): """ Computes the allegiance matrix with values representing the probability that nodes i and j were assigned to the same community by time-varying clustering methods. parameters ---------- community : array array of community assignment of size node,time returns ------- P : array module allegiance matrix, with P_ij probability that area i and j are in the same community Reference: ---------- Bassett, et al. (2013) “Robust detection of dynamic community structure in networks”, Chaos, 23, 1 """ N = community.shape[0] C = community.shape[1] T = P = np.zeros([N, N]) for t in range(len(community[0, :])): for i in range(len(community[:, 0])): for j in range(len(community[:, 0])): if i == j: continue # T_ij indicates the number of times that i and j are assigned to the same community across time if community[i][t] == community[j][t]: T[i, j] += 1 # module allegiance matrix, probability that ij were assigned to the same community P = (1/C)*T return P

if isinstance(ncontacts, list): if len(ncontacts) != nnodes: raise ValueError( 'Number of contacts, if a list, should be one per node') if isinstance(lam, list): if len(lam) != nnodes: raise ValueError( 'Lambda value of Poisson distribution, if a list, should be one per node') if isinstance(lam, list) and not isinstance(ncontacts, list) or not isinstance(lam, list) and isinstance(ncontacts, list): raise ValueError( 'When one of lambda or ncontacts is given as a list, the other argument must also be a list.') if nettype == 'bu': edgen = int((nnodes*(nnodes-1))/2) elif nettype == 'bd': edgen = int(nnodes*nnodes) if not isinstance(lam, list) and not isinstance(ncontacts, list): icts = np.random.poisson(lam, size=(edgen, ncontacts)) net = np.zeros([edgen, icts.sum(axis=1).max()+1]) for n in range(edgen): net[n, np.unique(np.cumsum(icts[n]))] = 1 else: icts = [] ict_max = 0 for n in range(edgen): icts.append(np.random.poisson(lam[n], size=ncontacts[n])) if sum(icts[-1]) > ict_max: ict_max = sum(icts[-1]) net = np.zeros([nnodes, ict_max+1]) for n in range(nnodes): net[n, np.unique(np.cumsum(icts[n]))] = 1 if nettype == 'bu': nettmp = np.zeros([nnodes, nnodes, net.shape[-1]]) ind = np.triu_indices(nnodes, k=1) nettmp[ind[0], ind[1], :] = net net = nettmp + nettmp.transpose([1, 0, 2]) elif nettype == 'bd': net = net.reshape([nnodes, nnodes, net.shape[-1]], order='F') net = set_diagonal(net, 0) if netrep == 'contact': if not netinfo: netinfo = {} netinfo['nettype'] = 'b' + nettype[-1] net = graphlet2contact(net, netinfo) return net

def rand_poisson(nnodes, ncontacts, lam=1, nettype='bu', netinfo=None, netrep='graphlet')

Generate a random network where intervals between contacts are distributed by a poisson distribution Parameters ---------- nnodes : int Number of nodes in networks ncontacts : int or list Number of expected contacts (i.e. edges). If list, number of contacts for each node. Any zeros drawn are ignored so returned degree of network can be smaller than ncontacts. lam : int or list Expectation of interval. nettype : str 'bu' or 'bd' netinfo : dict Dictionary of additional information netrep : str How the output should be. If ncontacts is a list, so should lam. Returns ------- net : array or dict Random network with intervals between active edges being Poisson distributed.

def rand_poisson(nnodes, ncontacts, lam=1, nettype='bu', netinfo=None, netrep='graphlet'): """ Generate a random network where intervals between contacts are distributed by a poisson distribution Parameters ---------- nnodes : int Number of nodes in networks ncontacts : int or list Number of expected contacts (i.e. edges). If list, number of contacts for each node. Any zeros drawn are ignored so returned degree of network can be smaller than ncontacts. lam : int or list Expectation of interval. nettype : str 'bu' or 'bd' netinfo : dict Dictionary of additional information netrep : str How the output should be. If ncontacts is a list, so should lam. Returns ------- net : array or dict Random network with intervals between active edges being Poisson distributed. """ if isinstance(ncontacts, list): if len(ncontacts) != nnodes: raise ValueError( 'Number of contacts, if a list, should be one per node') if isinstance(lam, list): if len(lam) != nnodes: raise ValueError( 'Lambda value of Poisson distribution, if a list, should be one per node') if isinstance(lam, list) and not isinstance(ncontacts, list) or not isinstance(lam, list) and isinstance(ncontacts, list): raise ValueError( 'When one of lambda or ncontacts is given as a list, the other argument must also be a list.') if nettype == 'bu': edgen = int((nnodes*(nnodes-1))/2) elif nettype == 'bd': edgen = int(nnodes*nnodes) if not isinstance(lam, list) and not isinstance(ncontacts, list): icts = np.random.poisson(lam, size=(edgen, ncontacts)) net = np.zeros([edgen, icts.sum(axis=1).max()+1]) for n in range(edgen): net[n, np.unique(np.cumsum(icts[n]))] = 1 else: icts = [] ict_max = 0 for n in range(edgen): icts.append(np.random.poisson(lam[n], size=ncontacts[n])) if sum(icts[-1]) > ict_max: ict_max = sum(icts[-1]) net = np.zeros([nnodes, ict_max+1]) for n in range(nnodes): net[n, np.unique(np.cumsum(icts[n]))] = 1 if nettype == 'bu': nettmp = np.zeros([nnodes, nnodes, net.shape[-1]]) ind = np.triu_indices(nnodes, k=1) nettmp[ind[0], ind[1], :] = net net = nettmp + nettmp.transpose([1, 0, 2]) elif nettype == 'bd': net = net.reshape([nnodes, nnodes, net.shape[-1]], order='F') net = set_diagonal(net, 0) if netrep == 'contact': if not netinfo: netinfo = {} netinfo['nettype'] = 'b' + nettype[-1] net = graphlet2contact(net, netinfo) return net

if not report: report = {} # Note the min value of all time series will now be at least 1. mindata = 1 - np.nanmin(data) data = data + mindata ind = np.triu_indices(data.shape[0], k=1) boxcox_list = np.array([sp.stats.boxcox(np.squeeze( data[ind[0][n], ind[1][n], :])) for n in range(0, len(ind[0]))]) boxcox_data = np.zeros(data.shape) boxcox_data[ind[0], ind[1], :] = np.vstack(boxcox_list[:, 0]) boxcox_data[ind[1], ind[0], :] = np.vstack(boxcox_list[:, 0]) bccheck = np.array(np.transpose(boxcox_data, [2, 0, 1])) bccheck = (bccheck - bccheck.mean(axis=0)) / bccheck.std(axis=0) bccheck = np.squeeze(np.mean(bccheck, axis=0)) np.fill_diagonal(bccheck, 0) report['boxcox'] = {} report['boxcox']['performed'] = 'yes' report['boxcox']['lambda'] = [ tuple([ind[0][n], ind[1][n], boxcox_list[n, -1]]) for n in range(0, len(ind[0]))] report['boxcox']['shift'] = mindata report['boxcox']['shited_to'] = 1 if np.sum(np.isnan(bccheck)) > 0: report['boxcox'] = {} report['boxcox']['performed'] = 'FAILED' report['boxcox']['failure_reason'] = ( 'Box cox transform is returning edges with uniform values through time. ' 'This is probabaly due to one or more outliers or a very skewed distribution. ' 'Have you corrected for sources of noise (e.g. movement)? ' 'If yes, some time-series might need additional transforms to approximate to Gaussian.' ) report['boxcox']['failure_consequence'] = ( 'Box cox transform was skipped from the postprocess pipeline.' ) boxcox_data = data - mindata error_msg = ('TENETO WARNING: Box Cox transform problem. \n' 'Box Cox transform not performed. \n' 'See report for more details.') print(error_msg) return boxcox_data, report

def postpro_boxcox(data, report=None)

Performs box cox transform on everything in data. If report variable is passed, this is added to the report.

def postpro_boxcox(data, report=None): """ Performs box cox transform on everything in data. If report variable is passed, this is added to the report. """ if not report: report = {} # Note the min value of all time series will now be at least 1. mindata = 1 - np.nanmin(data) data = data + mindata ind = np.triu_indices(data.shape[0], k=1) boxcox_list = np.array([sp.stats.boxcox(np.squeeze( data[ind[0][n], ind[1][n], :])) for n in range(0, len(ind[0]))]) boxcox_data = np.zeros(data.shape) boxcox_data[ind[0], ind[1], :] = np.vstack(boxcox_list[:, 0]) boxcox_data[ind[1], ind[0], :] = np.vstack(boxcox_list[:, 0]) bccheck = np.array(np.transpose(boxcox_data, [2, 0, 1])) bccheck = (bccheck - bccheck.mean(axis=0)) / bccheck.std(axis=0) bccheck = np.squeeze(np.mean(bccheck, axis=0)) np.fill_diagonal(bccheck, 0) report['boxcox'] = {} report['boxcox']['performed'] = 'yes' report['boxcox']['lambda'] = [ tuple([ind[0][n], ind[1][n], boxcox_list[n, -1]]) for n in range(0, len(ind[0]))] report['boxcox']['shift'] = mindata report['boxcox']['shited_to'] = 1 if np.sum(np.isnan(bccheck)) > 0: report['boxcox'] = {} report['boxcox']['performed'] = 'FAILED' report['boxcox']['failure_reason'] = ( 'Box cox transform is returning edges with uniform values through time. ' 'This is probabaly due to one or more outliers or a very skewed distribution. ' 'Have you corrected for sources of noise (e.g. movement)? ' 'If yes, some time-series might need additional transforms to approximate to Gaussian.' ) report['boxcox']['failure_consequence'] = ( 'Box cox transform was skipped from the postprocess pipeline.' ) boxcox_data = data - mindata error_msg = ('TENETO WARNING: Box Cox transform problem. \n' 'Box Cox transform not performed. \n' 'See report for more details.') print(error_msg) return boxcox_data, report

# Data should be timexnode report = {} # Derivative tdat = data[1:, :] - data[:-1, :] # Normalize tdat = tdat / np.std(tdat, axis=0) # Coupling coupling = np.array([tdat[:, i] * tdat[:, j] for i in np.arange(0, tdat.shape[1]) for j in np.arange(0, tdat.shape[1])]) coupling = np.reshape( coupling, [tdat.shape[1], tdat.shape[1], tdat.shape[0]]) # Average over window using strides shape = coupling.shape[:-1] + (coupling.shape[-1] - params['windowsize'] + 1, params['windowsize']) strides = coupling.strides + (coupling.strides[-1],) coupling_windowed = np.mean(np.lib.stride_tricks.as_strided( coupling, shape=shape, strides=strides), -1) report = {} report['method'] = 'temporalderivative' report['temporalderivative'] = {} report['temporalderivative']['windowsize'] = params['windowsize'] return coupling_windowed, report

def _temporal_derivative(data, params, report)

Performs mtd method. See func: teneto.derive.derive.

def _temporal_derivative(data, params, report): """ Performs mtd method. See func: teneto.derive.derive. """ # Data should be timexnode report = {} # Derivative tdat = data[1:, :] - data[:-1, :] # Normalize tdat = tdat / np.std(tdat, axis=0) # Coupling coupling = np.array([tdat[:, i] * tdat[:, j] for i in np.arange(0, tdat.shape[1]) for j in np.arange(0, tdat.shape[1])]) coupling = np.reshape( coupling, [tdat.shape[1], tdat.shape[1], tdat.shape[0]]) # Average over window using strides shape = coupling.shape[:-1] + (coupling.shape[-1] - params['windowsize'] + 1, params['windowsize']) strides = coupling.strides + (coupling.strides[-1],) coupling_windowed = np.mean(np.lib.stride_tricks.as_strided( coupling, shape=shape, strides=strides), -1) report = {} report['method'] = 'temporalderivative' report['temporalderivative'] = {} report['temporalderivative']['windowsize'] = params['windowsize'] return coupling_windowed, report

if threshold_type == 'percent': netout = binarize_percent(netin, threshold_level, sign, axis) elif threshold_type == 'magnitude': netout = binarize_magnitude(netin, threshold_level, sign) elif threshold_type == 'rdp': netout = binarize_rdp(netin, threshold_level, sign, axis) else: raise ValueError('Unknown value to parameter: threshold_type.') return netout

def binarize(netin, threshold_type, threshold_level, sign='pos', axis='time')

Binarizes a network, returning the network. General wrapper function for different binarization functions. Parameters ---------- netin : array or dict Network (graphlet or contact representation), threshold_type : str What type of thresholds to make binarization. Options: 'rdp', 'percent', 'magnitude'. threshold_level : str Paramter dependent on threshold type. If 'rdp', it is the delta (i.e. error allowed in compression). If 'percent', it is the percentage to keep (e.g. 0.1, means keep 10% of signal). If 'magnitude', it is the amplitude of signal to keep. sign : str, default='pos' States the sign of the thresholding. Can be 'pos', 'neg' or 'both'. If "neg", only negative values are thresholded and vice versa. axis : str Threshold over specfied axis. Valid for percent and rdp. Can be time or graphlet. Returns ------- netout : array or dict (depending on input) Binarized network

def binarize(netin, threshold_type, threshold_level, sign='pos', axis='time'): """ Binarizes a network, returning the network. General wrapper function for different binarization functions. Parameters ---------- netin : array or dict Network (graphlet or contact representation), threshold_type : str What type of thresholds to make binarization. Options: 'rdp', 'percent', 'magnitude'. threshold_level : str Paramter dependent on threshold type. If 'rdp', it is the delta (i.e. error allowed in compression). If 'percent', it is the percentage to keep (e.g. 0.1, means keep 10% of signal). If 'magnitude', it is the amplitude of signal to keep. sign : str, default='pos' States the sign of the thresholding. Can be 'pos', 'neg' or 'both'. If "neg", only negative values are thresholded and vice versa. axis : str Threshold over specfied axis. Valid for percent and rdp. Can be time or graphlet. Returns ------- netout : array or dict (depending on input) Binarized network """ if threshold_type == 'percent': netout = binarize_percent(netin, threshold_level, sign, axis) elif threshold_type == 'magnitude': netout = binarize_magnitude(netin, threshold_level, sign) elif threshold_type == 'rdp': netout = binarize_rdp(netin, threshold_level, sign, axis) else: raise ValueError('Unknown value to parameter: threshold_type.') return netout

inputtype = checkInput(netIn) # Convert TN to G representation if inputtype == 'TN' and 'TN' in allowedformats and outputformat != 'TN': G = netIn.df_to_array() netInfo = {'nettype': netIn.nettype, 'netshape': netIn.netshape} elif inputtype == 'TN' and 'TN' in allowedformats and outputformat == 'TN': TN = netIn elif inputtype == 'C' and 'C' in allowedformats and outputformat == 'G': G = contact2graphlet(netIn) netInfo = dict(netIn) netInfo.pop('contacts') elif inputtype == 'C' and 'C' in allowedformats and outputformat == 'TN': TN = TemporalNetwork(from_dict=netIn) elif inputtype == 'G' and 'G' in allowedformats and outputformat == 'TN': TN = TemporalNetwork(from_array=netIn) # Get network type if not set yet elif inputtype == 'G' and 'G' in allowedformats: netInfo = {} netInfo['netshape'] = netIn.shape netInfo['nettype'] = gen_nettype(netIn) G = netIn elif inputtype == 'C' and outputformat == 'C': pass else: raise ValueError('Input invalid.') if outputformat == 'TN' and not isinstance(TN.network, str): TN.network['i'] = TN.network['i'].astype(int) TN.network['j'] = TN.network['j'].astype(int) TN.network['t'] = TN.network['t'].astype(int) if outputformat == 'C' or outputformat == 'G': netInfo['inputtype'] = inputtype if inputtype != 'C' and outputformat == 'C': C = graphlet2contact(G, netInfo) if outputformat == 'G': return G, netInfo elif outputformat == 'C': return C elif outputformat == 'TN': return TN

def process_input(netIn, allowedformats, outputformat='G')

Takes input network and checks what the input is. Parameters ---------- netIn : array, dict, or TemporalNetwork Network (graphlet, contact or object) allowedformats : str Which format of network objects that are allowed. Options: 'C', 'TN', 'G'. outputformat: str, default=G Target output format. Options: 'C' or 'G'. Returns ------- C : dict OR G : array Graphlet representation. netInfo : dict Metainformation about network. OR tnet : object object of TemporalNetwork class

def process_input(netIn, allowedformats, outputformat='G'): """ Takes input network and checks what the input is. Parameters ---------- netIn : array, dict, or TemporalNetwork Network (graphlet, contact or object) allowedformats : str Which format of network objects that are allowed. Options: 'C', 'TN', 'G'. outputformat: str, default=G Target output format. Options: 'C' or 'G'. Returns ------- C : dict OR G : array Graphlet representation. netInfo : dict Metainformation about network. OR tnet : object object of TemporalNetwork class """ inputtype = checkInput(netIn) # Convert TN to G representation if inputtype == 'TN' and 'TN' in allowedformats and outputformat != 'TN': G = netIn.df_to_array() netInfo = {'nettype': netIn.nettype, 'netshape': netIn.netshape} elif inputtype == 'TN' and 'TN' in allowedformats and outputformat == 'TN': TN = netIn elif inputtype == 'C' and 'C' in allowedformats and outputformat == 'G': G = contact2graphlet(netIn) netInfo = dict(netIn) netInfo.pop('contacts') elif inputtype == 'C' and 'C' in allowedformats and outputformat == 'TN': TN = TemporalNetwork(from_dict=netIn) elif inputtype == 'G' and 'G' in allowedformats and outputformat == 'TN': TN = TemporalNetwork(from_array=netIn) # Get network type if not set yet elif inputtype == 'G' and 'G' in allowedformats: netInfo = {} netInfo['netshape'] = netIn.shape netInfo['nettype'] = gen_nettype(netIn) G = netIn elif inputtype == 'C' and outputformat == 'C': pass else: raise ValueError('Input invalid.') if outputformat == 'TN' and not isinstance(TN.network, str): TN.network['i'] = TN.network['i'].astype(int) TN.network['j'] = TN.network['j'].astype(int) TN.network['t'] = TN.network['t'].astype(int) if outputformat == 'C' or outputformat == 'G': netInfo['inputtype'] = inputtype if inputtype != 'C' and outputformat == 'C': C = graphlet2contact(G, netInfo) if outputformat == 'G': return G, netInfo elif outputformat == 'C': return C elif outputformat == 'TN': return TN

d = collections.OrderedDict() for c in C['contacts']: ct = tuple(c) if ct in d: d[ct] += 1 else: d[ct] = 1 new_contacts = [] new_values = [] for (key, value) in d.items(): new_values.append(value) new_contacts.append(key) C_out = C C_out['contacts'] = new_contacts C_out['values'] = new_values return C_out

def multiple_contacts_get_values(C)

Given an contact representation with repeated contacts, this function removes duplicates and creates a value Parameters ---------- C : dict contact representation with multiple repeated contacts. Returns ------- :C_out: dict Contact representation with duplicate contacts removed and the number of duplicates is now in the 'values' field.

def multiple_contacts_get_values(C): """ Given an contact representation with repeated contacts, this function removes duplicates and creates a value Parameters ---------- C : dict contact representation with multiple repeated contacts. Returns ------- :C_out: dict Contact representation with duplicate contacts removed and the number of duplicates is now in the 'values' field. """ d = collections.OrderedDict() for c in C['contacts']: ct = tuple(c) if ct in d: d[ct] += 1 else: d[ct] = 1 new_contacts = [] new_values = [] for (key, value) in d.items(): new_values.append(value) new_contacts.append(key) C_out = C C_out['contacts'] = new_contacts C_out['values'] = new_values return C_out

if len(df) > 0: idx = np.array(list(map(list, df.values))) G = np.zeros([netshape[0], netshape[0], netshape[1]]) if idx.shape[1] == 3: if nettype[-1] == 'u': idx = np.vstack([idx, idx[:, [1, 0, 2]]]) idx = idx.astype(int) G[idx[:, 0], idx[:, 1], idx[:, 2]] = 1 elif idx.shape[1] == 4: if nettype[-1] == 'u': idx = np.vstack([idx, idx[:, [1, 0, 2, 3]]]) weights = idx[:, 3] idx = np.array(idx[:, :3], dtype=int) G[idx[:, 0], idx[:, 1], idx[:, 2]] = weights else: G = np.zeros([netshape[0], netshape[0], netshape[1]]) return G

def df_to_array(df, netshape, nettype)

Returns a numpy array (snapshot representation) from thedataframe contact list Parameters: df : pandas df pandas df with columns, i,j,t. netshape : tuple network shape, format: (node, time) nettype : str 'wu', 'wd', 'bu', 'bd' Returns: -------- G : array (node,node,time) array for the network

def df_to_array(df, netshape, nettype): """ Returns a numpy array (snapshot representation) from thedataframe contact list Parameters: df : pandas df pandas df with columns, i,j,t. netshape : tuple network shape, format: (node, time) nettype : str 'wu', 'wd', 'bu', 'bd' Returns: -------- G : array (node,node,time) array for the network """ if len(df) > 0: idx = np.array(list(map(list, df.values))) G = np.zeros([netshape[0], netshape[0], netshape[1]]) if idx.shape[1] == 3: if nettype[-1] == 'u': idx = np.vstack([idx, idx[:, [1, 0, 2]]]) idx = idx.astype(int) G[idx[:, 0], idx[:, 1], idx[:, 2]] = 1 elif idx.shape[1] == 4: if nettype[-1] == 'u': idx = np.vstack([idx, idx[:, [1, 0, 2, 3]]]) weights = idx[:, 3] idx = np.array(idx[:, :3], dtype=int) G[idx[:, 0], idx[:, 1], idx[:, 2]] = weights else: G = np.zeros([netshape[0], netshape[0], netshape[1]]) return G

if distance_func_name == 'default' and netinfo['nettype'][0] == 'b': print('Default distance funciton specified. As network is binary, using Hamming') distance_func_name = 'hamming' elif distance_func_name == 'default' and netinfo['nettype'][0] == 'w': distance_func_name = 'euclidean' print( 'Default distance funciton specified. ' 'As network is weighted, using Euclidean') return distance_func_name

def check_distance_funciton_input(distance_func_name, netinfo)

Funciton checks distance_func_name, if it is specified as 'default'. Then given the type of the network selects a default distance function. Parameters ---------- distance_func_name : str distance function name. netinfo : dict the output of utils.process_input Returns ------- distance_func_name : str distance function name.

def check_distance_funciton_input(distance_func_name, netinfo): """ Funciton checks distance_func_name, if it is specified as 'default'. Then given the type of the network selects a default distance function. Parameters ---------- distance_func_name : str distance function name. netinfo : dict the output of utils.process_input Returns ------- distance_func_name : str distance function name. """ if distance_func_name == 'default' and netinfo['nettype'][0] == 'b': print('Default distance funciton specified. As network is binary, using Hamming') distance_func_name = 'hamming' elif distance_func_name == 'default' and netinfo['nettype'][0] == 'w': distance_func_name = 'euclidean' print( 'Default distance funciton specified. ' 'As network is weighted, using Euclidean') return distance_func_name

if isinstance(parcellation, str): parcin = '' if '+' in parcellation: parcin = parcellation parcellation = parcellation.split('+')[0] if '+OH' in parcin: subcortical = True else: subcortical = None if '+SUIT' in parcin: cerebellar = True else: cerebellar = None if not parc_type or not parc_params: path = tenetopath[0] + '/data/parcellation_defaults/defaults.json' with open(path) as data_file: defaults = json.load(data_file) if not parc_type: parc_type = defaults[parcellation]['type'] print('Using default parcellation type') if not parc_params: parc_params = defaults[parcellation]['params'] print('Using default parameters') if parc_type == 'sphere': parcellation = load_parcellation_coords(parcellation) seed = NiftiSpheresMasker(np.array(parcellation), **parc_params) data = seed.fit_transform(data_path) elif parc_type == 'region': path = tenetopath[0] + '/data/parcellation/' + parcellation + '.nii.gz' region = NiftiLabelsMasker(path, **parc_params) data = region.fit_transform(data_path) else: raise ValueError('Unknown parc_type specified') if subcortical: subatlas = fetch_atlas_harvard_oxford('sub-maxprob-thr0-2mm')['maps'] region = NiftiLabelsMasker(subatlas, **parc_params) data_sub = region.fit_transform(data_path) data = np.hstack([data, data_sub]) if cerebellar: path = tenetopath[0] + '/data/parcellation/Cerebellum-SUIT_space-MNI152NLin2009cAsym.nii.gz' region = NiftiLabelsMasker(path, **parc_params) data_cerebellar = region.fit_transform(data_path) data = np.hstack([data, data_cerebellar]) return data

def make_parcellation(data_path, parcellation, parc_type=None, parc_params=None)

Performs a parcellation which reduces voxel space to regions of interest (brain data). Parameters ---------- data_path : str Path to .nii image. parcellation : str Specify which parcellation that you would like to use. For MNI: 'gordon2014_333', 'power2012_264', For TAL: 'shen2013_278'. It is possible to add the OH subcotical atlas on top of a cortical atlas (e.g. gordon) by adding: '+OH' (for oxford harvard subcortical atlas) and '+SUIT' for SUIT cerebellar atlas. e.g.: gordon2014_333+OH+SUIT' parc_type : str Can be 'sphere' or 'region'. If nothing is specified, the default for that parcellation will be used. parc_params : dict **kwargs for nilearn functions Returns ------- data : array Data after the parcellation. NOTE ---- These functions make use of nilearn. Please cite nilearn if used in a publicaiton.

def make_parcellation(data_path, parcellation, parc_type=None, parc_params=None): """ Performs a parcellation which reduces voxel space to regions of interest (brain data). Parameters ---------- data_path : str Path to .nii image. parcellation : str Specify which parcellation that you would like to use. For MNI: 'gordon2014_333', 'power2012_264', For TAL: 'shen2013_278'. It is possible to add the OH subcotical atlas on top of a cortical atlas (e.g. gordon) by adding: '+OH' (for oxford harvard subcortical atlas) and '+SUIT' for SUIT cerebellar atlas. e.g.: gordon2014_333+OH+SUIT' parc_type : str Can be 'sphere' or 'region'. If nothing is specified, the default for that parcellation will be used. parc_params : dict **kwargs for nilearn functions Returns ------- data : array Data after the parcellation. NOTE ---- These functions make use of nilearn. Please cite nilearn if used in a publicaiton. """ if isinstance(parcellation, str): parcin = '' if '+' in parcellation: parcin = parcellation parcellation = parcellation.split('+')[0] if '+OH' in parcin: subcortical = True else: subcortical = None if '+SUIT' in parcin: cerebellar = True else: cerebellar = None if not parc_type or not parc_params: path = tenetopath[0] + '/data/parcellation_defaults/defaults.json' with open(path) as data_file: defaults = json.load(data_file) if not parc_type: parc_type = defaults[parcellation]['type'] print('Using default parcellation type') if not parc_params: parc_params = defaults[parcellation]['params'] print('Using default parameters') if parc_type == 'sphere': parcellation = load_parcellation_coords(parcellation) seed = NiftiSpheresMasker(np.array(parcellation), **parc_params) data = seed.fit_transform(data_path) elif parc_type == 'region': path = tenetopath[0] + '/data/parcellation/' + parcellation + '.nii.gz' region = NiftiLabelsMasker(path, **parc_params) data = region.fit_transform(data_path) else: raise ValueError('Unknown parc_type specified') if subcortical: subatlas = fetch_atlas_harvard_oxford('sub-maxprob-thr0-2mm')['maps'] region = NiftiLabelsMasker(subatlas, **parc_params) data_sub = region.fit_transform(data_path) data = np.hstack([data, data_sub]) if cerebellar: path = tenetopath[0] + '/data/parcellation/Cerebellum-SUIT_space-MNI152NLin2009cAsym.nii.gz' region = NiftiLabelsMasker(path, **parc_params) data_cerebellar = region.fit_transform(data_path) data = np.hstack([data, data_cerebellar]) return data

steps = (1.0/(N-1)) * (stop - start) if np.isscalar(steps): return steps*np.arange(N) + start else: return steps[:, None]*np.arange(N) + start[:, None]

def create_traj_ranges(start, stop, N)

Fills in the trajectory range. # Adapted from https://stackoverflow.com/a/40624614

def create_traj_ranges(start, stop, N): """ Fills in the trajectory range. # Adapted from https://stackoverflow.com/a/40624614 """ steps = (1.0/(N-1)) * (stop - start) if np.isscalar(steps): return steps*np.arange(N) + start else: return steps[:, None]*np.arange(N) + start[:, None]

newnetwork = tnet.network.copy() newnetwork['i'] = (tnet.network['i']) + \ ((tnet.netshape[0]) * (tnet.network['t'])) newnetwork['j'] = (tnet.network['j']) + \ ((tnet.netshape[0]) * (tnet.network['t'])) if 'weight' not in newnetwork.columns: newnetwork['weight'] = 1 newnetwork.drop('t', axis=1, inplace=True) timepointconns = pd.DataFrame() timepointconns['i'] = np.arange(0, (tnet.N*tnet.T)-tnet.N) timepointconns['j'] = np.arange(tnet.N, (tnet.N*tnet.T)) timepointconns['weight'] = intersliceweight supranet = pd.concat([newnetwork, timepointconns]).reset_index(drop=True) return supranet

def create_supraadjacency_matrix(tnet, intersliceweight=1)

Returns a supraadjacency matrix from a temporal network structure Parameters -------- tnet : TemporalNetwork Temporal network (any network type) intersliceweight : int Weight that links the same node from adjacent time-points Returns -------- supranet : dataframe Supraadjacency matrix

def create_supraadjacency_matrix(tnet, intersliceweight=1): """ Returns a supraadjacency matrix from a temporal network structure Parameters -------- tnet : TemporalNetwork Temporal network (any network type) intersliceweight : int Weight that links the same node from adjacent time-points Returns -------- supranet : dataframe Supraadjacency matrix """ newnetwork = tnet.network.copy() newnetwork['i'] = (tnet.network['i']) + \ ((tnet.netshape[0]) * (tnet.network['t'])) newnetwork['j'] = (tnet.network['j']) + \ ((tnet.netshape[0]) * (tnet.network['t'])) if 'weight' not in newnetwork.columns: newnetwork['weight'] = 1 newnetwork.drop('t', axis=1, inplace=True) timepointconns = pd.DataFrame() timepointconns['i'] = np.arange(0, (tnet.N*tnet.T)-tnet.N) timepointconns['j'] = np.arange(tnet.N, (tnet.N*tnet.T)) timepointconns['weight'] = intersliceweight supranet = pd.concat([newnetwork, timepointconns]).reset_index(drop=True) return supranet

r com_membership = np.array(com_membership) D = [] for i in range(com_membership.shape[0]): for j in range(i+1, com_membership.shape[0]): con = np.sum((com_membership[i, :] - com_membership[j, :]) == 0, axis=-1) / com_membership.shape[-1] twhere = np.where(con > th)[0] D += list(zip(*[np.repeat(i, len(twhere)).tolist(), np.repeat(j, len(twhere)).tolist(), twhere.tolist(), con[twhere].tolist()])) if len(D) > 0: D = pd.DataFrame(D, columns=['i', 'j', 't', 'weight']) D = TemporalNetwork(from_df=D) D = create_supraadjacency_matrix(D, intersliceweight=0) Dnx = tnet_to_nx(D) else: Dnx = None return Dnx

def make_consensus_matrix(com_membership, th=0.5)

r""" Makes the consensus matrix . Parameters ---------- com_membership : array Shape should be node, time, iteration. th : float threshold to cancel noisey edges Returns ------- D : array consensus matrix

def make_consensus_matrix(com_membership, th=0.5): """ r""" Makes the consensus matrix . Parameters ---------- com_membership : array Shape should be node, time, iteration. th : float threshold to cancel noisey edges Returns ------- D : array consensus matrix """ r com_membership = np.array(com_membership) D = [] for i in range(com_membership.shape[0]): for j in range(i+1, com_membership.shape[0]): con = np.sum((com_membership[i, :] - com_membership[j, :]) == 0, axis=-1) / com_membership.shape[-1] twhere = np.where(con > th)[0] D += list(zip(*[np.repeat(i, len(twhere)).tolist(), np.repeat(j, len(twhere)).tolist(), twhere.tolist(), con[twhere].tolist()])) if len(D) > 0: D = pd.DataFrame(D, columns=['i', 'j', 't', 'weight']) D = TemporalNetwork(from_df=D) D = create_supraadjacency_matrix(D, intersliceweight=0) Dnx = tnet_to_nx(D) else: Dnx = None return Dnx

r com_membership = np.array(com_membership) # make first indicies be between 0 and 1. com_membership[:, 0] = clean_community_indexes(com_membership[:, 0]) # loop over all timepoints, get jacccard distance in greedy manner for largest community to time period before for t in range(1, com_membership.shape[1]): ct, counts_t = np.unique(com_membership[:, t], return_counts=True) ct = ct[np.argsort(counts_t)[::-1]] c1back = np.unique(com_membership[:, t-1]) new_index = np.zeros(com_membership.shape[0]) for n in ct: if len(c1back) > 0: d = np.ones(int(c1back.max())+1) for m in c1back: v1 = np.zeros(com_membership.shape[0]) v2 = np.zeros(com_membership.shape[0]) v1[com_membership[:, t] == n] = 1 v2[com_membership[:, t-1] == m] = 1 d[int(m)] = jaccard(v1, v2) bestval = np.argmin(d) else: bestval = new_index.max() + 1 new_index[com_membership[:, t] == n] = bestval c1back = np.array(np.delete(c1back, np.where(c1back == bestval))) com_membership[:, t] = new_index return com_membership

def make_temporal_consensus(com_membership)

r""" Matches community labels accross time-points Jaccard matching is in a greedy fashiong. Matching the largest community at t with the community at t-1. Parameters ---------- com_membership : array Shape should be node, time. Returns ------- D : array temporal consensus matrix using Jaccard distance

def make_temporal_consensus(com_membership): """ r""" Matches community labels accross time-points Jaccard matching is in a greedy fashiong. Matching the largest community at t with the community at t-1. Parameters ---------- com_membership : array Shape should be node, time. Returns ------- D : array temporal consensus matrix using Jaccard distance """ r com_membership = np.array(com_membership) # make first indicies be between 0 and 1. com_membership[:, 0] = clean_community_indexes(com_membership[:, 0]) # loop over all timepoints, get jacccard distance in greedy manner for largest community to time period before for t in range(1, com_membership.shape[1]): ct, counts_t = np.unique(com_membership[:, t], return_counts=True) ct = ct[np.argsort(counts_t)[::-1]] c1back = np.unique(com_membership[:, t-1]) new_index = np.zeros(com_membership.shape[0]) for n in ct: if len(c1back) > 0: d = np.ones(int(c1back.max())+1) for m in c1back: v1 = np.zeros(com_membership.shape[0]) v2 = np.zeros(com_membership.shape[0]) v1[com_membership[:, t] == n] = 1 v2[com_membership[:, t-1] == m] = 1 d[int(m)] = jaccard(v1, v2) bestval = np.argmin(d) else: bestval = new_index.max() + 1 new_index[com_membership[:, t] == n] = bestval c1back = np.array(np.delete(c1back, np.where(c1back == bestval))) com_membership[:, t] = new_index return com_membership

# Preallocate flex = np.zeros(communities.shape[0]) # Go from the second time point to last, compare with time-point before for t in range(1, communities.shape[1]): flex[communities[:, t] != communities[:, t-1]] += 1 # Normalize flex = flex / (communities.shape[1] - 1) return flex

def flexibility(communities)

Amount a node changes community Parameters ---------- communities : array Community array of shape (node,time) Returns -------- flex : array Size with the flexibility of each node. Notes ----- Flexbility calculates the number of times a node switches its community label during a time series. It is normalized by the number of possible changes which could occur. It is important to make sure that the different community labels accross time points are not artbirary. References ----------- Bassett, DS, Wymbs N, Porter MA, Mucha P, Carlson JM, Grafton ST. Dynamic reconfiguration of human brain networks during learning. PNAS, 2011, 108(18):7641-6.

def flexibility(communities): """ Amount a node changes community Parameters ---------- communities : array Community array of shape (node,time) Returns -------- flex : array Size with the flexibility of each node. Notes ----- Flexbility calculates the number of times a node switches its community label during a time series. It is normalized by the number of possible changes which could occur. It is important to make sure that the different community labels accross time points are not artbirary. References ----------- Bassett, DS, Wymbs N, Porter MA, Mucha P, Carlson JM, Grafton ST. Dynamic reconfiguration of human brain networks during learning. PNAS, 2011, 108(18):7641-6. """ # Preallocate flex = np.zeros(communities.shape[0]) # Go from the second time point to last, compare with time-point before for t in range(1, communities.shape[1]): flex[communities[:, t] != communities[:, t-1]] += 1 # Normalize flex = flex / (communities.shape[1] - 1) return flex

relfun = [] threshold = [] for ec in exclusion_criteria: if ec[0:2] == '>=': relfun.append(np.greater_equal) threshold.append(float(ec[2:])) elif ec[0:2] == '<=': relfun.append(np.less_equal) threshold.append(float(ec[2:])) elif ec[0] == '>': relfun.append(np.greater) threshold.append(float(ec[1:])) elif ec[0] == '<': relfun.append(np.less) threshold.append(float(ec[1:])) else: raise ValueError('exclusion crieria must being with >,<,>= or <=') return relfun, threshold

def process_exclusion_criteria(exclusion_criteria)

Parses an exclusion critera string to get the function and threshold. Parameters ---------- exclusion_criteria : list list of strings where each string is of the format [relation][threshold]. E.g. \'<0.5\' or \'>=1\' Returns ------- relfun : list list of numpy functions for the exclusion criteria threshold : list list of floats for threshold for each relfun

def process_exclusion_criteria(exclusion_criteria): """ Parses an exclusion critera string to get the function and threshold. Parameters ---------- exclusion_criteria : list list of strings where each string is of the format [relation][threshold]. E.g. \'<0.5\' or \'>=1\' Returns ------- relfun : list list of numpy functions for the exclusion criteria threshold : list list of floats for threshold for each relfun """ relfun = [] threshold = [] for ec in exclusion_criteria: if ec[0:2] == '>=': relfun.append(np.greater_equal) threshold.append(float(ec[2:])) elif ec[0:2] == '<=': relfun.append(np.less_equal) threshold.append(float(ec[2:])) elif ec[0] == '>': relfun.append(np.greater) threshold.append(float(ec[1:])) elif ec[0] == '<': relfun.append(np.less) threshold.append(float(ec[1:])) else: raise ValueError('exclusion crieria must being with >,<,>= or <=') return relfun, threshold

# make sure the static and temporal communities have the same number of nodes if staticcommunities.shape[0] != temporalcommunities.shape[0]: raise ValueError( 'Temporal and static communities have different dimensions') alleg = allegiance(temporalcommunities) Rcoeff = np.zeros(len(staticcommunities)) for i, statcom in enumerate(staticcommunities): Rcoeff[i] = np.mean(alleg[i, staticcommunities == statcom]) return Rcoeff

def recruitment(temporalcommunities, staticcommunities)

Calculates recruitment coefficient for each node. Recruitment coefficient is the average probability of nodes from the same static communities being in the same temporal communities at other time-points or during different tasks. Parameters: ------------ temporalcommunities : array temporal communities vector (node,time) staticcommunities : array Static communities vector for each node Returns: ------- Rcoeff : array recruitment coefficient for each node References: ----------- Danielle S. Bassett, Muzhi Yang, Nicholas F. Wymbs, Scott T. Grafton. Learning-Induced Autonomy of Sensorimotor Systems. Nat Neurosci. 2015 May;18(5):744-51. Marcelo Mattar, Michael W. Cole, Sharon Thompson-Schill, Danielle S. Bassett. A Functional Cartography of Cognitive Systems. PLoS Comput Biol. 2015 Dec 2;11(12):e1004533.

def recruitment(temporalcommunities, staticcommunities): """ Calculates recruitment coefficient for each node. Recruitment coefficient is the average probability of nodes from the same static communities being in the same temporal communities at other time-points or during different tasks. Parameters: ------------ temporalcommunities : array temporal communities vector (node,time) staticcommunities : array Static communities vector for each node Returns: ------- Rcoeff : array recruitment coefficient for each node References: ----------- Danielle S. Bassett, Muzhi Yang, Nicholas F. Wymbs, Scott T. Grafton. Learning-Induced Autonomy of Sensorimotor Systems. Nat Neurosci. 2015 May;18(5):744-51. Marcelo Mattar, Michael W. Cole, Sharon Thompson-Schill, Danielle S. Bassett. A Functional Cartography of Cognitive Systems. PLoS Comput Biol. 2015 Dec 2;11(12):e1004533. """ # make sure the static and temporal communities have the same number of nodes if staticcommunities.shape[0] != temporalcommunities.shape[0]: raise ValueError( 'Temporal and static communities have different dimensions') alleg = allegiance(temporalcommunities) Rcoeff = np.zeros(len(staticcommunities)) for i, statcom in enumerate(staticcommunities): Rcoeff[i] = np.mean(alleg[i, staticcommunities == statcom]) return Rcoeff

# make sure the static and temporal communities have the same number of nodes if staticcommunities.shape[0] != temporalcommunities.shape[0]: raise ValueError( 'Temporal and static communities have different dimensions') alleg = allegiance(temporalcommunities) Icoeff = np.zeros(len(staticcommunities)) # calc integration for each node for i, statcom in enumerate(len(staticcommunities)): Icoeff[i] = np.mean(alleg[i, staticcommunities != statcom]) return Icoeff

def integration(temporalcommunities, staticcommunities)

Calculates the integration coefficient for each node. Measures the average probability that a node is in the same community as nodes from other systems. Parameters: ------------ temporalcommunities : array temporal communities vector (node,time) staticcommunities : array Static communities vector for each node Returns: ------- Icoeff : array integration coefficient for each node References: ---------- Danielle S. Bassett, Muzhi Yang, Nicholas F. Wymbs, Scott T. Grafton. Learning-Induced Autonomy of Sensorimotor Systems. Nat Neurosci. 2015 May;18(5):744-51. Marcelo Mattar, Michael W. Cole, Sharon Thompson-Schill, Danielle S. Bassett. A Functional Cartography of Cognitive Systems. PLoS Comput Biol. 2015 Dec 2;11(12):e1004533.

def integration(temporalcommunities, staticcommunities): """ Calculates the integration coefficient for each node. Measures the average probability that a node is in the same community as nodes from other systems. Parameters: ------------ temporalcommunities : array temporal communities vector (node,time) staticcommunities : array Static communities vector for each node Returns: ------- Icoeff : array integration coefficient for each node References: ---------- Danielle S. Bassett, Muzhi Yang, Nicholas F. Wymbs, Scott T. Grafton. Learning-Induced Autonomy of Sensorimotor Systems. Nat Neurosci. 2015 May;18(5):744-51. Marcelo Mattar, Michael W. Cole, Sharon Thompson-Schill, Danielle S. Bassett. A Functional Cartography of Cognitive Systems. PLoS Comput Biol. 2015 Dec 2;11(12):e1004533. """ # make sure the static and temporal communities have the same number of nodes if staticcommunities.shape[0] != temporalcommunities.shape[0]: raise ValueError( 'Temporal and static communities have different dimensions') alleg = allegiance(temporalcommunities) Icoeff = np.zeros(len(staticcommunities)) # calc integration for each node for i, statcom in enumerate(len(staticcommunities)): Icoeff[i] = np.mean(alleg[i, staticcommunities != statcom]) return Icoeff

lowest, highest = self.tracks[0].get_active_pitch_range() if len(self.tracks) > 1: for track in self.tracks[1:]: low, high = track.get_active_pitch_range() if low < lowest: lowest = low if high > highest: highest = high return lowest, highest

def get_active_pitch_range(self)

Return the active pitch range of the pianorolls of all tracks as a tuple (lowest, highest). Returns ------- lowest : int The lowest active pitch among the pianorolls of all tracks. highest : int The lowest highest pitch among the pianorolls of all tracks.

def get_active_pitch_range(self): """ Return the active pitch range of the pianorolls of all tracks as a tuple (lowest, highest). Returns ------- lowest : int The lowest active pitch among the pianorolls of all tracks. highest : int The lowest highest pitch among the pianorolls of all tracks. """ lowest, highest = self.tracks[0].get_active_pitch_range() if len(self.tracks) > 1: for track in self.tracks[1:]: low, high = track.get_active_pitch_range() if low < lowest: lowest = low if high > highest: highest = high return lowest, highest

empty_track_indices = [idx for idx, track in enumerate(self.tracks) if not np.any(track.pianoroll)] return empty_track_indices

def get_empty_tracks(self)

Return the indices of tracks with empty pianorolls. Returns ------- empty_track_indices : list The indices of tracks with empty pianorolls.

def get_empty_tracks(self): """ Return the indices of tracks with empty pianorolls. Returns ------- empty_track_indices : list The indices of tracks with empty pianorolls. """ empty_track_indices = [idx for idx, track in enumerate(self.tracks) if not np.any(track.pianoroll)] return empty_track_indices

if not isinstance(obj, Multitrack): raise TypeError("Support only `pypianoroll.Multitrack` class objects") copied = deepcopy(obj) copied.pad_to_same() return copied

def pad_to_same(obj)

Return a copy of the object with shorter piano-rolls padded with zeros at the end along the time axis to the length of the piano-roll with the maximal length.

def pad_to_same(obj): """ Return a copy of the object with shorter piano-rolls padded with zeros at the end along the time axis to the length of the piano-roll with the maximal length. """ if not isinstance(obj, Multitrack): raise TypeError("Support only `pypianoroll.Multitrack` class objects") copied = deepcopy(obj) copied.pad_to_same() return copied

_validate_pianoroll(pianoroll) reshaped = pianoroll[:, :120].reshape(-1, 12, 10) reshaped[..., :8] += pianoroll[:, 120:].reshape(-1, 1, 8) return np.sum(reshaped, 1)

def _to_chroma(pianoroll)

Return the unnormalized chroma features of a pianoroll.

def _to_chroma(pianoroll): """ Return the unnormalized chroma features of a pianoroll. """ _validate_pianoroll(pianoroll) reshaped = pianoroll[:, :120].reshape(-1, 12, 10) reshaped[..., :8] += pianoroll[:, 120:].reshape(-1, 1, 8) return np.sum(reshaped, 1)

_validate_pianoroll(pianoroll) reshaped = pianoroll.reshape(-1, beat_resolution * pianoroll.shape[1]) n_empty_beats = np.count_nonzero(reshaped.any(1)) return n_empty_beats / len(reshaped)

def empty_beat_rate(pianoroll, beat_resolution)

Return the ratio of empty beats to the total number of beats in a pianoroll.

def empty_beat_rate(pianoroll, beat_resolution): """ Return the ratio of empty beats to the total number of beats in a pianoroll. """ _validate_pianoroll(pianoroll) reshaped = pianoroll.reshape(-1, beat_resolution * pianoroll.shape[1]) n_empty_beats = np.count_nonzero(reshaped.any(1)) return n_empty_beats / len(reshaped)

_validate_pianoroll(pianoroll) chroma = _to_chroma(pianoroll) return np.count_nonzero(np.any(chroma, 0))

def n_pitche_classes_used(pianoroll)

Return the number of unique pitch classes used in a pianoroll.

def n_pitche_classes_used(pianoroll): """ Return the number of unique pitch classes used in a pianoroll. """ _validate_pianoroll(pianoroll) chroma = _to_chroma(pianoroll) return np.count_nonzero(np.any(chroma, 0))

_validate_pianoroll(pianoroll) if np.issubdtype(pianoroll.dtype, np.bool_): pianoroll = pianoroll.astype(np.uint8) padded = np.pad(pianoroll, ((1, 1), (0, 0)), 'constant') diff = np.diff(padded, axis=0).reshape(-1) onsets = (diff > 0).nonzero()[0] offsets = (diff < 0).nonzero()[0] n_qualified_notes = np.count_nonzero(offsets - onsets >= threshold) return n_qualified_notes / len(onsets)

def qualified_note_rate(pianoroll, threshold=2)

Return the ratio of the number of the qualified notes (notes longer than `threshold` (in time step)) to the total number of notes in a pianoroll.

def qualified_note_rate(pianoroll, threshold=2): """ Return the ratio of the number of the qualified notes (notes longer than `threshold` (in time step)) to the total number of notes in a pianoroll. """ _validate_pianoroll(pianoroll) if np.issubdtype(pianoroll.dtype, np.bool_): pianoroll = pianoroll.astype(np.uint8) padded = np.pad(pianoroll, ((1, 1), (0, 0)), 'constant') diff = np.diff(padded, axis=0).reshape(-1) onsets = (diff > 0).nonzero()[0] offsets = (diff < 0).nonzero()[0] n_qualified_notes = np.count_nonzero(offsets - onsets >= threshold) return n_qualified_notes / len(onsets)

if beat_resolution not in (4, 6, 8, 9, 12, 16, 18, 24): raise ValueError("Unsupported beat resolution. Only 4, 6, 8 ,9, 12, " "16, 18, 42 are supported.") _validate_pianoroll(pianoroll) def _drum_pattern_mask(res, tol): if res == 24: drum_pattern_mask = np.tile([1., tol, 0., 0., 0., tol], 4) elif res == 12: drum_pattern_mask = np.tile([1., tol, tol], 4) elif res == 6: drum_pattern_mask = np.tile([1., tol, tol], 2) elif res == 18: drum_pattern_mask = np.tile([1., tol, 0., 0., 0., tol], 3) elif res == 9: drum_pattern_mask = np.tile([1., tol, tol], 3) elif res == 16: drum_pattern_mask = np.tile([1., tol, 0., tol], 4) elif res == 8: drum_pattern_mask = np.tile([1., tol], 4) elif res == 4: drum_pattern_mask = np.tile([1., tol], 2) return drum_pattern_mask drum_pattern_mask = _drum_pattern_mask(beat_resolution, tolerance) n_in_pattern = np.sum(drum_pattern_mask * np.count_nonzero(pianoroll, 1)) return n_in_pattern / np.count_nonzero(pianoroll)

def drum_in_pattern_rate(pianoroll, beat_resolution, tolerance=0.1)

Return the ratio of the number of drum notes that lie on the drum pattern (i.e., at certain time steps) to the total number of drum notes.

def drum_in_pattern_rate(pianoroll, beat_resolution, tolerance=0.1): """ Return the ratio of the number of drum notes that lie on the drum pattern (i.e., at certain time steps) to the total number of drum notes. """ if beat_resolution not in (4, 6, 8, 9, 12, 16, 18, 24): raise ValueError("Unsupported beat resolution. Only 4, 6, 8 ,9, 12, " "16, 18, 42 are supported.") _validate_pianoroll(pianoroll) def _drum_pattern_mask(res, tol): if res == 24: drum_pattern_mask = np.tile([1., tol, 0., 0., 0., tol], 4) elif res == 12: drum_pattern_mask = np.tile([1., tol, tol], 4) elif res == 6: drum_pattern_mask = np.tile([1., tol, tol], 2) elif res == 18: drum_pattern_mask = np.tile([1., tol, 0., 0., 0., tol], 3) elif res == 9: drum_pattern_mask = np.tile([1., tol, tol], 3) elif res == 16: drum_pattern_mask = np.tile([1., tol, 0., tol], 4) elif res == 8: drum_pattern_mask = np.tile([1., tol], 4) elif res == 4: drum_pattern_mask = np.tile([1., tol], 2) return drum_pattern_mask drum_pattern_mask = _drum_pattern_mask(beat_resolution, tolerance) n_in_pattern = np.sum(drum_pattern_mask * np.count_nonzero(pianoroll, 1)) return n_in_pattern / np.count_nonzero(pianoroll)

if not isinstance(key, int): raise TypeError("`key` must an integer.") if key > 11 or key < 0: raise ValueError("`key` must be in an integer in between 0 and 11.") if kind not in ('major', 'minor'): raise ValueError("`kind` must be one of 'major' or 'minor'.") _validate_pianoroll(pianoroll) def _scale_mask(key, kind): if kind == 'major': a_scale_mask = np.array([0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1], bool) else: a_scale_mask = np.array([1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1], bool) return np.roll(a_scale_mask, key) chroma = _to_chroma(pianoroll) scale_mask = _scale_mask(key, kind) n_in_scale = np.sum(scale_mask.reshape(-1, 12) * chroma) return n_in_scale / np.count_nonzero(pianoroll)

def in_scale_rate(pianoroll, key=3, kind='major')

Return the ratio of the number of nonzero entries that lie in a specific scale to the total number of nonzero entries in a pianoroll. Default to C major scale.

def in_scale_rate(pianoroll, key=3, kind='major'): """ Return the ratio of the number of nonzero entries that lie in a specific scale to the total number of nonzero entries in a pianoroll. Default to C major scale. """ if not isinstance(key, int): raise TypeError("`key` must an integer.") if key > 11 or key < 0: raise ValueError("`key` must be in an integer in between 0 and 11.") if kind not in ('major', 'minor'): raise ValueError("`kind` must be one of 'major' or 'minor'.") _validate_pianoroll(pianoroll) def _scale_mask(key, kind): if kind == 'major': a_scale_mask = np.array([0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1], bool) else: a_scale_mask = np.array([1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1], bool) return np.roll(a_scale_mask, key) chroma = _to_chroma(pianoroll) scale_mask = _scale_mask(key, kind) n_in_scale = np.sum(scale_mask.reshape(-1, 12) * chroma) return n_in_scale / np.count_nonzero(pianoroll)

nonzero_steps = np.any(self.pianoroll, axis=1) inv_last_nonzero_step = np.argmax(np.flip(nonzero_steps, axis=0)) active_length = self.pianoroll.shape[0] - inv_last_nonzero_step return active_length

def get_active_length(self)

Return the active length (i.e., without trailing silence) of the pianoroll. The unit is time step. Returns ------- active_length : int The active length (i.e., without trailing silence) of the pianoroll.

def get_active_length(self): """ Return the active length (i.e., without trailing silence) of the pianoroll. The unit is time step. Returns ------- active_length : int The active length (i.e., without trailing silence) of the pianoroll. """ nonzero_steps = np.any(self.pianoroll, axis=1) inv_last_nonzero_step = np.argmax(np.flip(nonzero_steps, axis=0)) active_length = self.pianoroll.shape[0] - inv_last_nonzero_step return active_length

if self.pianoroll.shape[1] < 1: raise ValueError("Cannot compute the active pitch range for an " "empty pianoroll") lowest = 0 highest = 127 while lowest < highest: if np.any(self.pianoroll[:, lowest]): break lowest += 1 if lowest == highest: raise ValueError("Cannot compute the active pitch range for an " "empty pianoroll") while not np.any(self.pianoroll[:, highest]): highest -= 1 return lowest, highest

def get_active_pitch_range(self)

Return the active pitch range as a tuple (lowest, highest). Returns ------- lowest : int The lowest active pitch in the pianoroll. highest : int The highest active pitch in the pianoroll.

def get_active_pitch_range(self): """ Return the active pitch range as a tuple (lowest, highest). Returns ------- lowest : int The lowest active pitch in the pianoroll. highest : int The highest active pitch in the pianoroll. """ if self.pianoroll.shape[1] < 1: raise ValueError("Cannot compute the active pitch range for an " "empty pianoroll") lowest = 0 highest = 127 while lowest < highest: if np.any(self.pianoroll[:, lowest]): break lowest += 1 if lowest == highest: raise ValueError("Cannot compute the active pitch range for an " "empty pianoroll") while not np.any(self.pianoroll[:, highest]): highest -= 1 return lowest, highest

if x.shape[0] != 1: raise ValueError("Only one sample can be plotted at a time.") # compile theano function xs = T.tensor4('xs').astype(theano.config.floatX) get_activity = theano.function([xs], get_output(layer, xs)) activity = get_activity(x) shape = activity.shape nrows = np.ceil(np.sqrt(shape[1])).astype(int) ncols = nrows figs, axes = plt.subplots(nrows + 1, ncols, figsize=figsize, squeeze=False) axes[0, ncols // 2].imshow(1 - x[0][0], cmap='gray', interpolation='none') axes[0, ncols // 2].set_title('original') for ax in axes.flatten(): ax.set_xticks([]) ax.set_yticks([]) ax.axis('off') for i, (r, c) in enumerate(product(range(nrows), range(ncols))): if i >= shape[1]: break ndim = activity[0][i].ndim if ndim != 2: raise ValueError("Wrong number of dimensions, image data should " "have 2, instead got {}".format(ndim)) axes[r + 1, c].imshow(-activity[0][i], cmap='gray', interpolation='none') return plt

def plot_conv_activity(layer, x, figsize=(6, 8))

Plot the acitivities of a specific layer. Only really makes sense with layers that work 2D data (2D convolutional layers, 2D pooling layers ...). Parameters ---------- layer : lasagne.layers.Layer x : numpy.ndarray Only takes one sample at a time, i.e. x.shape[0] == 1.

def plot_conv_activity(layer, x, figsize=(6, 8)): """ Plot the acitivities of a specific layer. Only really makes sense with layers that work 2D data (2D convolutional layers, 2D pooling layers ...). Parameters ---------- layer : lasagne.layers.Layer x : numpy.ndarray Only takes one sample at a time, i.e. x.shape[0] == 1. """ if x.shape[0] != 1: raise ValueError("Only one sample can be plotted at a time.") # compile theano function xs = T.tensor4('xs').astype(theano.config.floatX) get_activity = theano.function([xs], get_output(layer, xs)) activity = get_activity(x) shape = activity.shape nrows = np.ceil(np.sqrt(shape[1])).astype(int) ncols = nrows figs, axes = plt.subplots(nrows + 1, ncols, figsize=figsize, squeeze=False) axes[0, ncols // 2].imshow(1 - x[0][0], cmap='gray', interpolation='none') axes[0, ncols // 2].set_title('original') for ax in axes.flatten(): ax.set_xticks([]) ax.set_yticks([]) ax.axis('off') for i, (r, c) in enumerate(product(range(nrows), range(ncols))): if i >= shape[1]: break ndim = activity[0][i].ndim if ndim != 2: raise ValueError("Wrong number of dimensions, image data should " "have 2, instead got {}".format(ndim)) axes[r + 1, c].imshow(-activity[0][i], cmap='gray', interpolation='none') return plt

import pydotplus as pydot pydot_graph = pydot.Dot('Network', graph_type='digraph') pydot_nodes = {} pydot_edges = [] for i, layer in enumerate(layers): layer_name = getattr(layer, 'name', None) if layer_name is None: layer_name = layer.__class__.__name__ layer_type = '{0}'.format(layer_name) key = repr(layer) label = layer_type color = get_hex_color(layer_type) if verbose: for attr in ['num_filters', 'num_units', 'ds', 'filter_shape', 'stride', 'strides', 'p']: if hasattr(layer, attr): label += '\n{0}: {1}'.format(attr, getattr(layer, attr)) if hasattr(layer, 'nonlinearity'): try: nonlinearity = layer.nonlinearity.__name__ except AttributeError: nonlinearity = layer.nonlinearity.__class__.__name__ label += '\nnonlinearity: {0}'.format(nonlinearity) if output_shape: label += '\nOutput shape: {0}'.format(layer.output_shape) pydot_nodes[key] = pydot.Node( key, label=label, shape='record', fillcolor=color, style='filled') if hasattr(layer, 'input_layers'): for input_layer in layer.input_layers: pydot_edges.append([repr(input_layer), key]) if hasattr(layer, 'input_layer'): pydot_edges.append([repr(layer.input_layer), key]) for node in pydot_nodes.values(): pydot_graph.add_node(node) for edges in pydot_edges: pydot_graph.add_edge( pydot.Edge(pydot_nodes[edges[0]], pydot_nodes[edges[1]])) return pydot_graph

def make_pydot_graph(layers, output_shape=True, verbose=False)

:parameters: - layers : list List of the layers, as obtained from lasagne.layers.get_all_layers - output_shape: (default `True`) If `True`, the output shape of each layer will be displayed. - verbose: (default `False`) If `True`, layer attributes like filter shape, stride, etc. will be displayed. :returns: - pydot_graph : PyDot object containing the graph

def make_pydot_graph(layers, output_shape=True, verbose=False): """ :parameters: - layers : list List of the layers, as obtained from lasagne.layers.get_all_layers - output_shape: (default `True`) If `True`, the output shape of each layer will be displayed. - verbose: (default `False`) If `True`, layer attributes like filter shape, stride, etc. will be displayed. :returns: - pydot_graph : PyDot object containing the graph """ import pydotplus as pydot pydot_graph = pydot.Dot('Network', graph_type='digraph') pydot_nodes = {} pydot_edges = [] for i, layer in enumerate(layers): layer_name = getattr(layer, 'name', None) if layer_name is None: layer_name = layer.__class__.__name__ layer_type = '{0}'.format(layer_name) key = repr(layer) label = layer_type color = get_hex_color(layer_type) if verbose: for attr in ['num_filters', 'num_units', 'ds', 'filter_shape', 'stride', 'strides', 'p']: if hasattr(layer, attr): label += '\n{0}: {1}'.format(attr, getattr(layer, attr)) if hasattr(layer, 'nonlinearity'): try: nonlinearity = layer.nonlinearity.__name__ except AttributeError: nonlinearity = layer.nonlinearity.__class__.__name__ label += '\nnonlinearity: {0}'.format(nonlinearity) if output_shape: label += '\nOutput shape: {0}'.format(layer.output_shape) pydot_nodes[key] = pydot.Node( key, label=label, shape='record', fillcolor=color, style='filled') if hasattr(layer, 'input_layers'): for input_layer in layer.input_layers: pydot_edges.append([repr(input_layer), key]) if hasattr(layer, 'input_layer'): pydot_edges.append([repr(layer.input_layer), key]) for node in pydot_nodes.values(): pydot_graph.add_node(node) for edges in pydot_edges: pydot_graph.add_edge( pydot.Edge(pydot_nodes[edges[0]], pydot_nodes[edges[1]])) return pydot_graph

from IPython.display import Image layers = (layers.get_all_layers() if hasattr(layers, 'get_all_layers') else layers) dot = make_pydot_graph(layers, **kwargs) return Image(dot.create_png())

def draw_to_notebook(layers, **kwargs)

Draws a network diagram in an IPython notebook :parameters: - layers : list or NeuralNet instance List of layers or the neural net to draw. - **kwargs : see the docstring of make_pydot_graph for other options

def draw_to_notebook(layers, **kwargs): """ Draws a network diagram in an IPython notebook :parameters: - layers : list or NeuralNet instance List of layers or the neural net to draw. - **kwargs : see the docstring of make_pydot_graph for other options """ from IPython.display import Image layers = (layers.get_all_layers() if hasattr(layers, 'get_all_layers') else layers) dot = make_pydot_graph(layers, **kwargs) return Image(dot.create_png())

from decaf.util import transform # soft dep _JEFFNET_FLIP = True # first, extract the 256x256 center. image = transform.scale_and_extract(transform.as_rgb(image), 256) # convert to [0,255] float32 image = image.astype(np.float32) * 255. if _JEFFNET_FLIP: # Flip the image if necessary, maintaining the c_contiguous order image = image[::-1, :].copy() # subtract the mean image -= self.net_._data_mean return image

def prepare_image(self, image)

Returns image of shape `(256, 256, 3)`, as expected by `transform` when `classify_direct = True`.

def prepare_image(self, image): """ Returns image of shape `(256, 256, 3)`, as expected by `transform` when `classify_direct = True`. """ from decaf.util import transform # soft dep _JEFFNET_FLIP = True # first, extract the 256x256 center. image = transform.scale_and_extract(transform.as_rgb(image), 256) # convert to [0,255] float32 image = image.astype(np.float32) * 255. if _JEFFNET_FLIP: # Flip the image if necessary, maintaining the c_contiguous order image = image[::-1, :].copy() # subtract the mean image -= self.net_._data_mean return image

mapping = kwargs if args: if len(args) != 1 or not isinstance(args[0], dict): raise RedisError('MSET requires **kwargs or a single dict arg') mapping.update(args[0]) if len(mapping) == 0: raise ResponseError("wrong number of arguments for 'mset' command") for key, value in mapping.items(): self.set(key, value) return True

def mset(self, *args, **kwargs)

Sets key/values based on a mapping. Mapping can be supplied as a single dictionary argument or as kwargs.

def mset(self, *args, **kwargs): """ Sets key/values based on a mapping. Mapping can be supplied as a single dictionary argument or as kwargs. """ mapping = kwargs if args: if len(args) != 1 or not isinstance(args[0], dict): raise RedisError('MSET requires **kwargs or a single dict arg') mapping.update(args[0]) if len(mapping) == 0: raise ResponseError("wrong number of arguments for 'mset' command") for key, value in mapping.items(): self.set(key, value) return True

redis_hash = self._get_hash(hashkey, 'HEXISTS') return self._encode(attribute) in redis_hash

def hexists(self, hashkey, attribute)

Emulate hexists.

def hexists(self, hashkey, attribute): """ Emulate hexists. """ redis_hash = self._get_hash(hashkey, 'HEXISTS') return self._encode(attribute) in redis_hash

disco = self.dependencies[aioxmpp.disco.DiscoClient] response = yield from disco.query_info( peer_jid, ) return namespaces.xep0050_commands in response.features

def supports_commands(self, peer_jid)

Detect whether a peer supports :xep:`50` Ad-Hoc commands. :param peer_jid: JID of the peer to query :type peer_jid: :class:`aioxmpp.JID` :rtype: :class:`bool` :return: True if the peer supports the Ad-Hoc commands protocol, false otherwise. Note that the fact that a peer supports the protocol does not imply that it offers any commands.

def supports_commands(self, peer_jid): """ Detect whether a peer supports :xep:`50` Ad-Hoc commands. :param peer_jid: JID of the peer to query :type peer_jid: :class:`aioxmpp.JID` :rtype: :class:`bool` :return: True if the peer supports the Ad-Hoc commands protocol, false otherwise. Note that the fact that a peer supports the protocol does not imply that it offers any commands. """ disco = self.dependencies[aioxmpp.disco.DiscoClient] response = yield from disco.query_info( peer_jid, ) return namespaces.xep0050_commands in response.features

if self._response is not None: raise RuntimeError("command execution already started") request = aioxmpp.IQ( type_=aioxmpp.IQType.SET, to=self._peer_jid, payload=adhoc_xso.Command(self._command_name), ) self._response = yield from self._stream.send_iq_and_wait_for_reply( request, ) return self._response.first_payload

def start(self)

Initiate the session by starting to execute the command with the peer. :return: The :attr:`~.xso.Command.first_payload` of the response This sends an empty command IQ request with the :attr:`~.ActionType.EXECUTE` action. The :attr:`status`, :attr:`response` and related attributes get updated with the newly received values.

def start(self): """ Initiate the session by starting to execute the command with the peer. :return: The :attr:`~.xso.Command.first_payload` of the response This sends an empty command IQ request with the :attr:`~.ActionType.EXECUTE` action. The :attr:`status`, :attr:`response` and related attributes get updated with the newly received values. """ if self._response is not None: raise RuntimeError("command execution already started") request = aioxmpp.IQ( type_=aioxmpp.IQType.SET, to=self._peer_jid, payload=adhoc_xso.Command(self._command_name), ) self._response = yield from self._stream.send_iq_and_wait_for_reply( request, ) return self._response.first_payload

if self._this_occupant is not None: items = [self._this_occupant] else: items = [] items += list(self._occupant_info.values()) return items

def members(self)

A copy of the list of occupants. The local user is always the first item in the list, unless the :meth:`on_enter` has not fired yet.

def members(self): """ A copy of the list of occupants. The local user is always the first item in the list, unless the :meth:`on_enter` has not fired yet. """ if self._this_occupant is not None: items = [self._this_occupant] else: items = [] items += list(self._occupant_info.values()) return items

keys = list(self.keys()) try: keys.remove(None) except ValueError: pass keys.sort() key = lookup_language(keys, language_ranges) return self[key]

def lookup(self, language_ranges)

Perform an RFC4647 language range lookup on the keys in the dictionary. `language_ranges` must be a sequence of :class:`LanguageRange` instances. Return the entry in the dictionary with a key as produced by `lookup_language`. If `lookup_language` does not find a match and the mapping contains an entry with key :data:`None`, that entry is returned, otherwise :class:`KeyError` is raised.

def lookup(self, language_ranges): """ Perform an RFC4647 language range lookup on the keys in the dictionary. `language_ranges` must be a sequence of :class:`LanguageRange` instances. Return the entry in the dictionary with a key as produced by `lookup_language`. If `lookup_language` does not find a match and the mapping contains an entry with key :data:`None`, that entry is returned, otherwise :class:`KeyError` is raised. """ keys = list(self.keys()) try: keys.remove(None) except ValueError: pass keys.sort() key = lookup_language(keys, language_ranges) return self[key]

record = b".".join([ b"_" + service.encode("ascii"), b"_" + transport.encode("ascii"), domain]) answer = yield from repeated_query( record, dns.rdatatype.SRV, **kwargs) if answer is None: return None items = [ (rec.priority, rec.weight, (str(rec.target), rec.port)) for rec in answer ] for i, (prio, weight, (host, port)) in enumerate(items): if host == ".": raise ValueError( "protocol {!r} over {!r} not supported at {!r}".format( service, transport, domain ) ) items[i] = (prio, weight, ( host.rstrip(".").encode("ascii"), port)) return items

def lookup_srv( domain: bytes, service: str, transport: str = "tcp", **kwargs)

Query the DNS for SRV records describing how the given `service` over the given `transport` is implemented for the given `domain`. `domain` must be an IDNA-encoded :class:`bytes` object; `service` must be a normal :class:`str`. Keyword arguments are passed to :func:`repeated_query`. Return a list of tuples ``(prio, weight, (hostname, port))``, where `hostname` is a IDNA-encoded :class:`bytes` object containing the hostname obtained from the SRV record. The other fields are also as obtained from the SRV records. The trailing dot is stripped from the `hostname`. If the DNS query returns an empty result, :data:`None` is returned. If any of the found SRV records has the root zone (``.``) as `hostname`, this indicates that the service is not available at the given `domain` and :class:`ValueError` is raised.

def lookup_srv( domain: bytes, service: str, transport: str = "tcp", **kwargs): """ Query the DNS for SRV records describing how the given `service` over the given `transport` is implemented for the given `domain`. `domain` must be an IDNA-encoded :class:`bytes` object; `service` must be a normal :class:`str`. Keyword arguments are passed to :func:`repeated_query`. Return a list of tuples ``(prio, weight, (hostname, port))``, where `hostname` is a IDNA-encoded :class:`bytes` object containing the hostname obtained from the SRV record. The other fields are also as obtained from the SRV records. The trailing dot is stripped from the `hostname`. If the DNS query returns an empty result, :data:`None` is returned. If any of the found SRV records has the root zone (``.``) as `hostname`, this indicates that the service is not available at the given `domain` and :class:`ValueError` is raised. """ record = b".".join([ b"_" + service.encode("ascii"), b"_" + transport.encode("ascii"), domain]) answer = yield from repeated_query( record, dns.rdatatype.SRV, **kwargs) if answer is None: return None items = [ (rec.priority, rec.weight, (str(rec.target), rec.port)) for rec in answer ] for i, (prio, weight, (host, port)) in enumerate(items): if host == ".": raise ValueError( "protocol {!r} over {!r} not supported at {!r}".format( service, transport, domain ) ) items[i] = (prio, weight, ( host.rstrip(".").encode("ascii"), port)) return items

record = b".".join([ b"_" + str(port).encode("ascii"), b"_" + transport.encode("ascii"), hostname ]) answer = yield from repeated_query( record, dns.rdatatype.TLSA, require_ad=require_ad, **kwargs) if answer is None: return None items = [ (rec.usage, rec.selector, rec.mtype, rec.cert) for rec in answer ] return items

def lookup_tlsa(hostname, port, transport="tcp", require_ad=True, **kwargs)

Query the DNS for TLSA records describing the certificates and/or keys to expect when contacting `hostname` at the given `port` over the given `transport`. `hostname` must be an IDNA-encoded :class:`bytes` object. The keyword arguments are passed to :func:`repeated_query`; `require_ad` defaults to :data:`True` here. Return a list of tuples ``(usage, selector, mtype, cert)`` which contains the information from the TLSA records. If no data is returned by the query, :data:`None` is returned instead.

def lookup_tlsa(hostname, port, transport="tcp", require_ad=True, **kwargs): """ Query the DNS for TLSA records describing the certificates and/or keys to expect when contacting `hostname` at the given `port` over the given `transport`. `hostname` must be an IDNA-encoded :class:`bytes` object. The keyword arguments are passed to :func:`repeated_query`; `require_ad` defaults to :data:`True` here. Return a list of tuples ``(usage, selector, mtype, cert)`` which contains the information from the TLSA records. If no data is returned by the query, :data:`None` is returned instead. """ record = b".".join([ b"_" + str(port).encode("ascii"), b"_" + transport.encode("ascii"), hostname ]) answer = yield from repeated_query( record, dns.rdatatype.TLSA, require_ad=require_ad, **kwargs) if answer is None: return None items = [ (rec.usage, rec.selector, rec.mtype, rec.cert) for rec in answer ] return items

parts = [ _process_identity(identity) for identity in identities ] parts.sort() return b"".join(parts)+b"\x1c"

def _process_identities(identities)

Generate the `Identities String` from an iterable of identities. :param identities: The identities to generate the features string from. :type identities: :class:`~collections.abc.Iterable` of :class:`~.disco.xso.Identity` :return: The `Identities String` :rtype: :class:`bytes` Generate the `Identities String` from the given `identities` as specified in :xep:`390`.

def _process_identities(identities): """ Generate the `Identities String` from an iterable of identities. :param identities: The identities to generate the features string from. :type identities: :class:`~collections.abc.Iterable` of :class:`~.disco.xso.Identity` :return: The `Identities String` :rtype: :class:`bytes` Generate the `Identities String` from the given `identities` as specified in :xep:`390`. """ parts = [ _process_identity(identity) for identity in identities ] parts.sort() return b"".join(parts)+b"\x1c"

parts = [ _process_form(form) for form in exts ] parts.sort() return b"".join(parts)+b"\x1c"

def _process_extensions(exts)

Generate the `Extensions String` from an iterable of data forms. :param exts: The data forms to generate the extensions string from. :type exts: :class:`~collections.abc.Iterable` of :class:`~.forms.xso.Data` :return: The `Extensions String` :rtype: :class:`bytes` Generate the `Extensions String` from the given `exts` as specified in :xep:`390`.

def _process_extensions(exts): """ Generate the `Extensions String` from an iterable of data forms. :param exts: The data forms to generate the extensions string from. :type exts: :class:`~collections.abc.Iterable` of :class:`~.forms.xso.Data` :return: The `Extensions String` :rtype: :class:`bytes` Generate the `Extensions String` from the given `exts` as specified in :xep:`390`. """ parts = [ _process_form(form) for form in exts ] parts.sort() return b"".join(parts)+b"\x1c"

stanza = aioxmpp.Presence() self._state.apply_to_stanza(stanza) stanza.status.update(self._status) return stanza

def make_stanza(self)

Create and return a presence stanza with the current settings. :return: Presence stanza :rtype: :class:`aioxmpp.Presence`

def make_stanza(self): """ Create and return a presence stanza with the current settings. :return: Presence stanza :rtype: :class:`aioxmpp.Presence` """ stanza = aioxmpp.Presence() self._state.apply_to_stanza(stanza) stanza.status.update(self._status) return stanza

if not isinstance(priority, numbers.Integral): raise TypeError( "invalid priority: got {}, expected integer".format( type(priority) ) ) if not isinstance(state, aioxmpp.PresenceState): raise TypeError( "invalid state: got {}, expected aioxmpp.PresenceState".format( type(state), ) ) if isinstance(status, str): new_status = {None: status} else: new_status = dict(status) new_priority = int(priority) emit_state_event = self._state != state emit_overall_event = ( emit_state_event or self._priority != new_priority or self._status != new_status ) self._state = state self._status = new_status self._priority = new_priority if emit_state_event: self.on_presence_state_changed() if emit_overall_event: self.on_presence_changed() return self.resend_presence()

def set_presence(self, state, status={}, priority=0)

Change the presence broadcast by the client. :param state: New presence state to broadcast :type state: :class:`aioxmpp.PresenceState` :param status: New status information to broadcast :type status: :class:`dict` or :class:`str` :param priority: New priority for the resource :type priority: :class:`int` :return: Stanza token of the presence stanza or :data:`None` if the presence is unchanged or the stream is not connected. :rtype: :class:`~.stream.StanzaToken` If the client is currently connected, the new presence is broadcast immediately. `status` must be either a string or something which can be passed to the :class:`dict` constructor. If it is a string, it is wrapped into a dict using ``{None: status}``. The mapping must map :class:`~.LanguageTag` objects (or :data:`None`) to strings. The information will be used to generate internationalised presence status information. If you do not need internationalisation, simply use the string version of the argument.

def set_presence(self, state, status={}, priority=0): """ Change the presence broadcast by the client. :param state: New presence state to broadcast :type state: :class:`aioxmpp.PresenceState` :param status: New status information to broadcast :type status: :class:`dict` or :class:`str` :param priority: New priority for the resource :type priority: :class:`int` :return: Stanza token of the presence stanza or :data:`None` if the presence is unchanged or the stream is not connected. :rtype: :class:`~.stream.StanzaToken` If the client is currently connected, the new presence is broadcast immediately. `status` must be either a string or something which can be passed to the :class:`dict` constructor. If it is a string, it is wrapped into a dict using ``{None: status}``. The mapping must map :class:`~.LanguageTag` objects (or :data:`None`) to strings. The information will be used to generate internationalised presence status information. If you do not need internationalisation, simply use the string version of the argument. """ if not isinstance(priority, numbers.Integral): raise TypeError( "invalid priority: got {}, expected integer".format( type(priority) ) ) if not isinstance(state, aioxmpp.PresenceState): raise TypeError( "invalid state: got {}, expected aioxmpp.PresenceState".format( type(state), ) ) if isinstance(status, str): new_status = {None: status} else: new_status = dict(status) new_priority = int(priority) emit_state_event = self._state != state emit_overall_event = ( emit_state_event or self._priority != new_priority or self._status != new_status ) self._state = state self._status = new_status self._priority = new_priority if emit_state_event: self.on_presence_state_changed() if emit_overall_event: self.on_presence_changed() return self.resend_presence()

pk = pyasn1_struct.getComponentByName( "tbsCertificate" ).getComponentByName( "subjectPublicKeyInfo" ) return pyasn1.codec.der.encoder.encode(pk)

def extract_pk_blob_from_pyasn1(pyasn1_struct)

Extract an ASN.1 encoded public key blob from the given :mod:`pyasn1` structure (which must represent a certificate).

def extract_pk_blob_from_pyasn1(pyasn1_struct): """ Extract an ASN.1 encoded public key blob from the given :mod:`pyasn1` structure (which must represent a certificate). """ pk = pyasn1_struct.getComponentByName( "tbsCertificate" ).getComponentByName( "subjectPublicKeyInfo" ) return pyasn1.codec.der.encoder.encode(pk)

cert_structure = extract_python_dict_from_x509(x509) try: ssl.match_hostname(cert_structure, hostname) except ssl.CertificateError: return False return True

def check_x509_hostname(x509, hostname)

Check whether the given :class:`OpenSSL.crypto.X509` certificate `x509` matches the given `hostname`. Return :data:`True` if the name matches and :data:`False` otherwise. This uses :func:`ssl.match_hostname` and :func:`extract_python_dict_from_x509`.

def check_x509_hostname(x509, hostname): """ Check whether the given :class:`OpenSSL.crypto.X509` certificate `x509` matches the given `hostname`. Return :data:`True` if the name matches and :data:`False` otherwise. This uses :func:`ssl.match_hostname` and :func:`extract_python_dict_from_x509`. """ cert_structure = extract_python_dict_from_x509(x509) try: ssl.match_hostname(cert_structure, hostname) except ssl.CertificateError: return False return True

key = self._x509_key(x509) try: pins = self._storage[hostname] except KeyError: return None if key in pins: return True return None

def query(self, hostname, x509)

Return true if the given :class:`OpenSSL.crypto.X509` object `x509` has previously been pinned for use with the given `hostname` and :data:`None` otherwise. Returning :data:`None` allows this method to be used with :class:`PinningPKIXCertificateVerifier`.

def query(self, hostname, x509): """ Return true if the given :class:`OpenSSL.crypto.X509` object `x509` has previously been pinned for use with the given `hostname` and :data:`None` otherwise. Returning :data:`None` allows this method to be used with :class:`PinningPKIXCertificateVerifier`. """ key = self._x509_key(x509) try: pins = self._storage[hostname] except KeyError: return None if key in pins: return True return None

try: mechanisms = features[SASLMechanisms] except KeyError: logger.error("No sasl mechanisms: %r", list(features)) raise errors.SASLUnavailable( "Remote side does not support SASL") from None remote_mechanism_list = mechanisms.get_mechanism_list() for our_mechanism in mechanism_classes: token = our_mechanism.any_supported(remote_mechanism_list) if token is not None: return our_mechanism, token return None, None

def _find_supported(self, features, mechanism_classes)

Find the first mechansim class which supports a mechanism announced in the given stream features. :param features: Current XMPP stream features :type features: :class:`~.nonza.StreamFeatures` :param mechanism_classes: SASL mechanism classes to use :type mechanism_classes: iterable of :class:`SASLMechanism` sub\\ *classes* :raises aioxmpp.errors.SASLUnavailable: if the peer does not announce SASL support :return: the :class:`SASLMechanism` subclass to use and a token :rtype: pair Return a supported SASL mechanism class, by looking the given stream features `features`. If no matching mechanism is found, ``(None, None)`` is returned. Otherwise, a pair consisting of the mechanism class and the value returned by the respective :meth:`~.sasl.SASLMechanism.any_supported` method is returned. The latter is an opaque token which must be passed to the `token` argument of :meth:`_execute` or :meth:`aiosasl.SASLMechanism.authenticate`.

def _find_supported(self, features, mechanism_classes): """ Find the first mechansim class which supports a mechanism announced in the given stream features. :param features: Current XMPP stream features :type features: :class:`~.nonza.StreamFeatures` :param mechanism_classes: SASL mechanism classes to use :type mechanism_classes: iterable of :class:`SASLMechanism` sub\\ *classes* :raises aioxmpp.errors.SASLUnavailable: if the peer does not announce SASL support :return: the :class:`SASLMechanism` subclass to use and a token :rtype: pair Return a supported SASL mechanism class, by looking the given stream features `features`. If no matching mechanism is found, ``(None, None)`` is returned. Otherwise, a pair consisting of the mechanism class and the value returned by the respective :meth:`~.sasl.SASLMechanism.any_supported` method is returned. The latter is an opaque token which must be passed to the `token` argument of :meth:`_execute` or :meth:`aiosasl.SASLMechanism.authenticate`. """ try: mechanisms = features[SASLMechanisms] except KeyError: logger.error("No sasl mechanisms: %r", list(features)) raise errors.SASLUnavailable( "Remote side does not support SASL") from None remote_mechanism_list = mechanisms.get_mechanism_list() for our_mechanism in mechanism_classes: token = our_mechanism.any_supported(remote_mechanism_list) if token is not None: return our_mechanism, token return None, None

if isinstance(tag, str): namespace_uri, sep, localname = tag.partition("}") if sep: if not namespace_uri.startswith("{"): raise ValueError("not a valid etree-format tag") namespace_uri = namespace_uri[1:] else: localname = namespace_uri namespace_uri = None return (namespace_uri, localname) elif len(tag) != 2: raise ValueError("not a valid tuple-format tag") else: if any(part is not None and not isinstance(part, str) for part in tag): raise TypeError("tuple-format tags must only contain str and None") if tag[1] is None: raise ValueError("tuple-format localname must not be None") return tag

def normalize_tag(tag)

Normalize an XML element tree `tag` into the tuple format. The following input formats are accepted: * ElementTree namespaced string, e.g. ``{uri:bar}foo`` * Unnamespaced tags, e.g. ``foo`` * Two-tuples consisting of `namespace_uri` and `localpart`; `namespace_uri` may be :data:`None` if the tag is supposed to be namespaceless. Otherwise it must be, like `localpart`, a :class:`str`. Return a two-tuple consisting the ``(namespace_uri, localpart)`` format.

def normalize_tag(tag): """ Normalize an XML element tree `tag` into the tuple format. The following input formats are accepted: * ElementTree namespaced string, e.g. ``{uri:bar}foo`` * Unnamespaced tags, e.g. ``foo`` * Two-tuples consisting of `namespace_uri` and `localpart`; `namespace_uri` may be :data:`None` if the tag is supposed to be namespaceless. Otherwise it must be, like `localpart`, a :class:`str`. Return a two-tuple consisting the ``(namespace_uri, localpart)`` format. """ if isinstance(tag, str): namespace_uri, sep, localname = tag.partition("}") if sep: if not namespace_uri.startswith("{"): raise ValueError("not a valid etree-format tag") namespace_uri = namespace_uri[1:] else: localname = namespace_uri namespace_uri = None return (namespace_uri, localname) elif len(tag) != 2: raise ValueError("not a valid tuple-format tag") else: if any(part is not None and not isinstance(part, str) for part in tag): raise TypeError("tuple-format tags must only contain str and None") if tag[1] is None: raise ValueError("tuple-format localname must not be None") return tag

disco_info = yield from self._disco_client.query_info(other_entity) intersection = disco_info.features & SUPPORTED_HASH_FEATURES if (not intersection and namespaces.xep0300_hashes2 not in disco_info.features): raise RuntimeError( "Remote does not support the urn:xmpp:hashes:2 feature.") return intersection

def select_common_hashes(self, other_entity)

Return the list of algos supported by us and `other_entity`. The algorithms are represented by their :xep:`300` URNs (`urn:xmpp:hash-function-text-names:...`). :param other_entity: the address of another entity :type other_entity: :class:`aioxmpp.JID` :returns: the identifiers of the hash algorithms supported by both us and the other entity :rtype: :class:`set` :raises RuntimeError: if the other entity does not support the :xep:`300` feature nor does not publish hash functions URNs we support. Note: This assumes the protocol is supported if valid hash function features are detected, even if `urn:xmpp:hashes:2` is not listed as a feature.

def select_common_hashes(self, other_entity): """ Return the list of algos supported by us and `other_entity`. The algorithms are represented by their :xep:`300` URNs (`urn:xmpp:hash-function-text-names:...`). :param other_entity: the address of another entity :type other_entity: :class:`aioxmpp.JID` :returns: the identifiers of the hash algorithms supported by both us and the other entity :rtype: :class:`set` :raises RuntimeError: if the other entity does not support the :xep:`300` feature nor does not publish hash functions URNs we support. Note: This assumes the protocol is supported if valid hash function features are detected, even if `urn:xmpp:hashes:2` is not listed as a feature. """ disco_info = yield from self._disco_client.query_info(other_entity) intersection = disco_info.features & SUPPORTED_HASH_FEATURES if (not intersection and namespaces.xep0300_hashes2 not in disco_info.features): raise RuntimeError( "Remote does not support the urn:xmpp:hashes:2 feature.") return intersection

iq = aioxmpp.IQ( type_=aioxmpp.IQType.GET, payload=private_xml_xso.Query(query_xso) ) return (yield from self.client.send(iq))

def get_private_xml(self, query_xso)

Get the private XML data for the element `query_xso` from the server. :param query_xso: the object to retrieve. :returns: the stored private XML data. `query_xso` *must* serialize to an empty XML node of the wanted namespace and type and *must* be registered as private XML :class:`~private_xml_xso.Query` payload.

def get_private_xml(self, query_xso): """ Get the private XML data for the element `query_xso` from the server. :param query_xso: the object to retrieve. :returns: the stored private XML data. `query_xso` *must* serialize to an empty XML node of the wanted namespace and type and *must* be registered as private XML :class:`~private_xml_xso.Query` payload. """ iq = aioxmpp.IQ( type_=aioxmpp.IQType.GET, payload=private_xml_xso.Query(query_xso) ) return (yield from self.client.send(iq))

result = cls() result._features = { feature for feature in other_node.iter_features() if feature not in cls.STATIC_FEATURES } for category, type_, lang, name in other_node.iter_identities(): names = result._identities.setdefault( (category, type_), aioxmpp.structs.LanguageMap() ) names[lang] = name result.items = list(other_node.iter_items()) return result

def clone(cls, other_node)

Clone another :class:`Node` and return as :class:`StaticNode`. :param other_node: The node which shall be cloned :type other_node: :class:`Node` :rtype: :class:`StaticNode` :return: A static node which has the exact same features, identities and items as `other_node`. The features and identities are copied over into the resulting :class:`StaticNode`. The items of `other_node` are not copied but merely referenced, so changes to the item *objects* of `other_node` will be reflected in the result. .. versionadded:: 0.9

def clone(cls, other_node): """ Clone another :class:`Node` and return as :class:`StaticNode`. :param other_node: The node which shall be cloned :type other_node: :class:`Node` :rtype: :class:`StaticNode` :return: A static node which has the exact same features, identities and items as `other_node`. The features and identities are copied over into the resulting :class:`StaticNode`. The items of `other_node` are not copied but merely referenced, so changes to the item *objects* of `other_node` will be reflected in the result. .. versionadded:: 0.9 """ result = cls() result._features = { feature for feature in other_node.iter_features() if feature not in cls.STATIC_FEATURES } for category, type_, lang, name in other_node.iter_identities(): names = result._identities.setdefault( (category, type_), aioxmpp.structs.LanguageMap() ) names[lang] = name result.items = list(other_node.iter_items()) return result

if self.plural is not None: n, _ = formatter.get_field(self.number_index, args, kwargs) translated = translator.ngettext(self.singular, self.plural, n) else: translated = translator.gettext(self.singular) return formatter.vformat(translated, args, kwargs)

def localize(self, formatter, translator, *args, **kwargs)

Localize and format the string using the given `formatter` and `translator`. The remaining args are passed to the :meth:`~LocalizingFormatter.format` method of the `formatter`. The `translator` must be an object supporting the :class:`gettext.NullTranslations` interface. If :attr:`plural` is not :data:`None`, the number which will be passed to the `ngettext` method of `translator` is first extracted from the `args` or `kwargs`, depending on :attr:`number_index`. The whole semantics of all three are described in :meth:`string.Formatter.get_field`, which is used by this method (:attr:`number_index` is passed as `field_name`). The value returned by :meth:`~string.Formatter.get_field` is then used as third argument to `ngettext`, while the others are sourced from :attr:`singular` and :attr:`plural`. If :attr:`plural` is :data:`None`, the `gettext` method of `translator` is used with :attr:`singular` as its only argument. After the translation step, the `formatter` is used with the translated string and `args` and `kwargs` to obtain a formatted version of the string which is then returned. All of this works best when using a :class:`LocalizingFormatter`.

def localize(self, formatter, translator, *args, **kwargs): """ Localize and format the string using the given `formatter` and `translator`. The remaining args are passed to the :meth:`~LocalizingFormatter.format` method of the `formatter`. The `translator` must be an object supporting the :class:`gettext.NullTranslations` interface. If :attr:`plural` is not :data:`None`, the number which will be passed to the `ngettext` method of `translator` is first extracted from the `args` or `kwargs`, depending on :attr:`number_index`. The whole semantics of all three are described in :meth:`string.Formatter.get_field`, which is used by this method (:attr:`number_index` is passed as `field_name`). The value returned by :meth:`~string.Formatter.get_field` is then used as third argument to `ngettext`, while the others are sourced from :attr:`singular` and :attr:`plural`. If :attr:`plural` is :data:`None`, the `gettext` method of `translator` is used with :attr:`singular` as its only argument. After the translation step, the `formatter` is used with the translated string and `args` and `kwargs` to obtain a formatted version of the string which is then returned. All of this works best when using a :class:`LocalizingFormatter`. """ if self.plural is not None: n, _ = formatter.get_field(self.number_index, args, kwargs) translated = translator.ngettext(self.singular, self.plural, n) else: translated = translator.gettext(self.singular) return formatter.vformat(translated, args, kwargs)

item = cls(xso_item.jid) item.update_from_xso_item(xso_item) return item

def from_xso_item(cls, xso_item)

Create a :class:`Item` with the :attr:`jid` set to the :attr:`.xso.Item.jid` obtained from `xso_item`. Then update that instance with `xso_item` using :meth:`update_from_xso_item` and return it.

def from_xso_item(cls, xso_item): """ Create a :class:`Item` with the :attr:`jid` set to the :attr:`.xso.Item.jid` obtained from `xso_item`. Then update that instance with `xso_item` using :meth:`update_from_xso_item` and return it. """ item = cls(xso_item.jid) item.update_from_xso_item(xso_item) return item

result = forms_xso.Field( var=self.field.var, type_=self.field.FIELD_TYPE, ) if use_local_metadata: result.desc = self.desc result.label = self.label result.required = self.required else: try: result.desc = self._desc except AttributeError: pass try: result.label = self._label except AttributeError: pass try: result.required = self._required except AttributeError: pass return result

def render(self, *, use_local_metadata=True)

Return a :class:`~.Field` containing the values and metadata set in the field. :param use_local_metadata: if true, the description, label and required metadata can be sourced from the field descriptor associated with this bound field. :type use_local_metadata: :class:`bool` :return: A new :class:`~.Field` instance. The returned object uses the values accessible through this object; that means, any values set for e.g. :attr:`desc` take precedence over the values declared at the class level. If `use_local_metadata` is false, values declared at the class level are not used if no local values are declared. This is useful when generating a reply to a form received by a peer, as it avoids sending a modified form. This method is must be overriden and is thus marked abstract. However, when called from a subclass, it creates the :class:`~.Field` instance and initialises its :attr:`~.Field.var`, :attr:`~.Field.type_`, :attr:`~.Field.desc`, :attr:`~.Field.required` and :attr:`~.Field.label` attributes and returns the result. Subclasses are supposed to override this method, call the base implementation through :func:`super` to obtain the :class:`~.Field` instance and then fill in the values and/or options.

def render(self, *, use_local_metadata=True): """ Return a :class:`~.Field` containing the values and metadata set in the field. :param use_local_metadata: if true, the description, label and required metadata can be sourced from the field descriptor associated with this bound field. :type use_local_metadata: :class:`bool` :return: A new :class:`~.Field` instance. The returned object uses the values accessible through this object; that means, any values set for e.g. :attr:`desc` take precedence over the values declared at the class level. If `use_local_metadata` is false, values declared at the class level are not used if no local values are declared. This is useful when generating a reply to a form received by a peer, as it avoids sending a modified form. This method is must be overriden and is thus marked abstract. However, when called from a subclass, it creates the :class:`~.Field` instance and initialises its :attr:`~.Field.var`, :attr:`~.Field.type_`, :attr:`~.Field.desc`, :attr:`~.Field.required` and :attr:`~.Field.label` attributes and returns the result. Subclasses are supposed to override this method, call the base implementation through :func:`super` to obtain the :class:`~.Field` instance and then fill in the values and/or options. """ result = forms_xso.Field( var=self.field.var, type_=self.field.FIELD_TYPE, ) if use_local_metadata: result.desc = self.desc result.label = self.label result.required = self.required else: try: result.desc = self._desc except AttributeError: pass try: result.label = self._label except AttributeError: pass try: result.required = self._required except AttributeError: pass return result

buf = io.BytesIO() gen = XMPPXMLGenerator(buf, short_empty_elements=True, sorted_attributes=True) x.unparse_to_sax(gen) return buf.getvalue().decode("utf8")

def serialize_single_xso(x)

Serialize a single XSO `x` to a string. This is potentially very slow and should only be used for debugging purposes. It is generally more efficient to use a :class:`XMPPXMLGenerator` to stream elements.

def serialize_single_xso(x): """ Serialize a single XSO `x` to a string. This is potentially very slow and should only be used for debugging purposes. It is generally more efficient to use a :class:`XMPPXMLGenerator` to stream elements. """ buf = io.BytesIO() gen = XMPPXMLGenerator(buf, short_empty_elements=True, sorted_attributes=True) x.unparse_to_sax(gen) return buf.getvalue().decode("utf8")

result = None def cb(instance): nonlocal result result = instance read_xso(src, {type_: cb}) return result

def read_single_xso(src, type_)

Read a single :class:`~.XSO` of the given `type_` from the binary file-like input `src` and return the instance.

def read_single_xso(src, type_): """ Read a single :class:`~.XSO` of the given `type_` from the binary file-like input `src` and return the instance. """ result = None def cb(instance): nonlocal result result = instance read_xso(src, {type_: cb}) return result

if isinstance(self, type): result = self() else: result = copy.deepcopy(self) result.max_ = max_ return result

def limit(self, max_)

Limit the result set to a given number of items. :param max_: Maximum number of items to return. :type max_: :class:`int` or :data:`None` :rtype: :class:`ResultSetMetadata` :return: A new request set up to request at most `max_` items. This method can be called on the class and on objects. When called on objects, it returns a copy of the object with :attr:`max_` set accordingly. When called on the class, it creates a fresh object with :attr:`max_` set accordingly.

def limit(self, max_): """ Limit the result set to a given number of items. :param max_: Maximum number of items to return. :type max_: :class:`int` or :data:`None` :rtype: :class:`ResultSetMetadata` :return: A new request set up to request at most `max_` items. This method can be called on the class and on objects. When called on objects, it returns a copy of the object with :attr:`max_` set accordingly. When called on the class, it creates a fresh object with :attr:`max_` set accordingly. """ if isinstance(self, type): result = self() else: result = copy.deepcopy(self) result.max_ = max_ return result

if self == to: return True if self == FieldType.TEXT_SINGLE and to == FieldType.TEXT_PRIVATE: return True return False

def allow_upcast(self, to)

Return true if the field type may be upcast to the other field type `to`. This relation specifies when it is safe to transfer data from this field type to the given other field type `to`. This is the case if any of the following holds true: * `to` is equal to this type * this type is :attr:`TEXT_SINGLE` and `to` is :attr:`TEXT_PRIVATE`

def allow_upcast(self, to): """ Return true if the field type may be upcast to the other field type `to`. This relation specifies when it is safe to transfer data from this field type to the given other field type `to`. This is the case if any of the following holds true: * `to` is equal to this type * this type is :attr:`TEXT_SINGLE` and `to` is :attr:`TEXT_PRIVATE` """ if self == to: return True if self == FieldType.TEXT_SINGLE and to == FieldType.TEXT_PRIVATE: return True return False

cls = type(xso.XSO)(name, (xso.XSO,), { "TAG": tag, }) Error.as_application_condition(cls) return cls

def make_application_error(name, tag)

Create and return a **class** inheriting from :class:`.xso.XSO`. The :attr:`.xso.XSO.TAG` is set to `tag` and the class’ name will be `name`. In addition, the class is automatically registered with :attr:`.Error.application_condition` using :meth:`~.Error.as_application_condition`. Keep in mind that if you subclass the class returned by this function, the subclass is not registered with :class:`.Error`. In addition, if you do not override the :attr:`~.xso.XSO.TAG`, you will not be able to register the subclass as application defined condition as it has the same tag as the class returned by this function, which has already been registered as application condition.

def make_application_error(name, tag): """ Create and return a **class** inheriting from :class:`.xso.XSO`. The :attr:`.xso.XSO.TAG` is set to `tag` and the class’ name will be `name`. In addition, the class is automatically registered with :attr:`.Error.application_condition` using :meth:`~.Error.as_application_condition`. Keep in mind that if you subclass the class returned by this function, the subclass is not registered with :class:`.Error`. In addition, if you do not override the :attr:`~.xso.XSO.TAG`, you will not be able to register the subclass as application defined condition as it has the same tag as the class returned by this function, which has already been registered as application condition. """ cls = type(xso.XSO)(name, (xso.XSO,), { "TAG": tag, }) Error.as_application_condition(cls) return cls

result = cls( condition=exc.condition, type_=exc.TYPE, text=exc.text ) result.application_condition = exc.application_defined_condition return result

def from_exception(cls, exc)

Construct a new :class:`Error` payload from the attributes of the exception. :param exc: The exception to convert :type exc: :class:`aioxmpp.errors.XMPPError` :result: Newly constructed error payload :rtype: :class:`Error` .. versionchanged:: 0.10 The :attr:`aioxmpp.XMPPError.application_defined_condition` is now taken over into the result.

def from_exception(cls, exc): """ Construct a new :class:`Error` payload from the attributes of the exception. :param exc: The exception to convert :type exc: :class:`aioxmpp.errors.XMPPError` :result: Newly constructed error payload :rtype: :class:`Error` .. versionchanged:: 0.10 The :attr:`aioxmpp.XMPPError.application_defined_condition` is now taken over into the result. """ result = cls( condition=exc.condition, type_=exc.TYPE, text=exc.text ) result.application_condition = exc.application_defined_condition return result

response = yield from self._disco.query_info(jid) result = set() for feature in response.features: try: result.add(pubsub_xso.Feature(feature)) except ValueError: continue return result

def get_features(self, jid)

Return the features supported by a service. :param jid: Address of the PubSub service to query. :type jid: :class:`aioxmpp.JID` :return: Set of supported features :rtype: set containing :class:`~.pubsub.xso.Feature` enumeration members. This simply uses service discovery to obtain the set of features and converts the features to :class:`~.pubsub.xso.Feature` enumeration members. To get the full feature information, resort to using :meth:`.DiscoClient.query_info` directly on `jid`. Features returned by the peer which are not valid pubsub features are not returned.

def get_features(self, jid): """ Return the features supported by a service. :param jid: Address of the PubSub service to query. :type jid: :class:`aioxmpp.JID` :return: Set of supported features :rtype: set containing :class:`~.pubsub.xso.Feature` enumeration members. This simply uses service discovery to obtain the set of features and converts the features to :class:`~.pubsub.xso.Feature` enumeration members. To get the full feature information, resort to using :meth:`.DiscoClient.query_info` directly on `jid`. Features returned by the peer which are not valid pubsub features are not returned. """ response = yield from self._disco.query_info(jid) result = set() for feature in response.features: try: result.add(pubsub_xso.Feature(feature)) except ValueError: continue return result

publish = pubsub_xso.Publish() publish.node = node if payload is not None: item = pubsub_xso.Item() item.id_ = id_ item.registered_payload = payload publish.item = item iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.SET) iq.payload = pubsub_xso.Request( publish ) if publish_options is not None: features = yield from self.get_features(jid) if pubsub_xso.Feature.PUBLISH_OPTIONS not in features: raise RuntimeError( "publish-options given, but not supported by server" ) iq.payload.publish_options = pubsub_xso.PublishOptions() iq.payload.publish_options.data = publish_options response = yield from self.client.send(iq) if response is not None and response.payload.item is not None: return response.payload.item.id_ or id_ return id_

def publish(self, jid, node, payload, *, id_=None, publish_options=None)

Publish an item to a node. :param jid: Address of the PubSub service. :type jid: :class:`aioxmpp.JID` :param node: Name of the PubSub node to publish to. :type node: :class:`str` :param payload: Registered payload to publish. :type payload: :class:`aioxmpp.xso.XSO` :param id_: Item ID to use for the item. :type id_: :class:`str` or :data:`None`. :param publish_options: A data form with the options for the publish request :type publish_options: :class:`aioxmpp.forms.Data` :raises aioxmpp.errors.XMPPError: as returned by the service :raises RuntimeError: if `publish_options` is not :data:`None` but the service does not support `publish_options` :return: The Item ID which was used to publish the item. :rtype: :class:`str` or :data:`None` Publish the given `payload` (which must be a :class:`aioxmpp.xso.XSO` registered with :attr:`.xso.Item.registered_payload`). The item is published to `node` at `jid`. If `id_` is given, it is used as the ID for the item. If an item with the same ID already exists at the node, it is replaced. If no ID is given, a ID is generated by the server. If `publish_options` is given, it is passed as ``<publish-options/>`` element to the server. This needs to be a data form which allows to define e.g. node configuration as a pre-condition to publishing. If the publish-options cannot be satisfied, the server will raise a :attr:`aioxmpp.ErrorCondition.CONFLICT` error. If `publish_options` is given and the server does not announce the :attr:`aioxmpp.pubsub.xso.Feature.PUBLISH_OPTIONS` feature, :class:`RuntimeError` is raised to prevent security issues (e.g. if the publish options attempt to assert a restrictive access model). Return the ID of the item as published (or :data:`None` if the server does not inform us; this is unfortunately common).

def publish(self, jid, node, payload, *, id_=None, publish_options=None): """ Publish an item to a node. :param jid: Address of the PubSub service. :type jid: :class:`aioxmpp.JID` :param node: Name of the PubSub node to publish to. :type node: :class:`str` :param payload: Registered payload to publish. :type payload: :class:`aioxmpp.xso.XSO` :param id_: Item ID to use for the item. :type id_: :class:`str` or :data:`None`. :param publish_options: A data form with the options for the publish request :type publish_options: :class:`aioxmpp.forms.Data` :raises aioxmpp.errors.XMPPError: as returned by the service :raises RuntimeError: if `publish_options` is not :data:`None` but the service does not support `publish_options` :return: The Item ID which was used to publish the item. :rtype: :class:`str` or :data:`None` Publish the given `payload` (which must be a :class:`aioxmpp.xso.XSO` registered with :attr:`.xso.Item.registered_payload`). The item is published to `node` at `jid`. If `id_` is given, it is used as the ID for the item. If an item with the same ID already exists at the node, it is replaced. If no ID is given, a ID is generated by the server. If `publish_options` is given, it is passed as ``<publish-options/>`` element to the server. This needs to be a data form which allows to define e.g. node configuration as a pre-condition to publishing. If the publish-options cannot be satisfied, the server will raise a :attr:`aioxmpp.ErrorCondition.CONFLICT` error. If `publish_options` is given and the server does not announce the :attr:`aioxmpp.pubsub.xso.Feature.PUBLISH_OPTIONS` feature, :class:`RuntimeError` is raised to prevent security issues (e.g. if the publish options attempt to assert a restrictive access model). Return the ID of the item as published (or :data:`None` if the server does not inform us; this is unfortunately common). """ publish = pubsub_xso.Publish() publish.node = node if payload is not None: item = pubsub_xso.Item() item.id_ = id_ item.registered_payload = payload publish.item = item iq = aioxmpp.stanza.IQ(to=jid, type_=aioxmpp.structs.IQType.SET) iq.payload = pubsub_xso.Request( publish ) if publish_options is not None: features = yield from self.get_features(jid) if pubsub_xso.Feature.PUBLISH_OPTIONS not in features: raise RuntimeError( "publish-options given, but not supported by server" ) iq.payload.publish_options = pubsub_xso.PublishOptions() iq.payload.publish_options.data = publish_options response = yield from self.client.send(iq) if response is not None and response.payload.item is not None: return response.payload.item.id_ or id_ return id_

response = yield from self._disco.query_items( jid, node=node, ) result = [] for item in response.items: if item.jid != jid: continue result.append(( item.node, item.name, )) return result

def get_nodes(self, jid, node=None)

Request all nodes at a service or collection node. :param jid: Address of the PubSub service. :type jid: :class:`aioxmpp.JID` :param node: Name of the collection node to query :type node: :class:`str` or :data:`None` :raises aioxmpp.errors.XMPPError: as returned by the service :return: The list of nodes at the service or collection node. :rtype: :class:`~collections.abc.Sequence` of tuples consisting of the node name and its description. Request the nodes available at `jid`. If `node` is not :data:`None`, the request returns the children of the :xep:`248` collection node `node`. Make sure to check for the appropriate server feature first. Return a list of tuples consisting of the node names and their description (if available, otherwise :data:`None`). If more information is needed, use :meth:`.DiscoClient.get_items` directly. Only nodes whose :attr:`~.disco.xso.Item.jid` match the `jid` are returned.

def get_nodes(self, jid, node=None): """ Request all nodes at a service or collection node. :param jid: Address of the PubSub service. :type jid: :class:`aioxmpp.JID` :param node: Name of the collection node to query :type node: :class:`str` or :data:`None` :raises aioxmpp.errors.XMPPError: as returned by the service :return: The list of nodes at the service or collection node. :rtype: :class:`~collections.abc.Sequence` of tuples consisting of the node name and its description. Request the nodes available at `jid`. If `node` is not :data:`None`, the request returns the children of the :xep:`248` collection node `node`. Make sure to check for the appropriate server feature first. Return a list of tuples consisting of the node names and their description (if available, otherwise :data:`None`). If more information is needed, use :meth:`.DiscoClient.get_items` directly. Only nodes whose :attr:`~.disco.xso.Item.jid` match the `jid` are returned. """ response = yield from self._disco.query_items( jid, node=node, ) result = [] for item in response.items: if item.jid != jid: continue result.append(( item.node, item.name, )) return result

dest = [("start", )+tuple(ev_args)] result = yield from capture_events( super().parse_events(ev_args, parent_ctx), dest ) result._set_captured_events(dest) return result

def parse_events(cls, ev_args, parent_ctx)

Capture the events sent to :meth:`.XSO.parse_events`, including the initial `ev_args` to a list and call :meth:`_set_captured_events` on the result of :meth:`.XSO.parse_events`. Like the method it overrides, :meth:`parse_events` is suspendable.

def parse_events(cls, ev_args, parent_ctx): """ Capture the events sent to :meth:`.XSO.parse_events`, including the initial `ev_args` to a list and call :meth:`_set_captured_events` on the result of :meth:`.XSO.parse_events`. Like the method it overrides, :meth:`parse_events` is suspendable. """ dest = [("start", )+tuple(ev_args)] result = yield from capture_events( super().parse_events(ev_args, parent_ctx), dest ) result._set_captured_events(dest) return result