public class LabelPositioningUtils
extends java.lang.Object
getLabelCoordinates
methods.| Constructor and Description |
|---|
LabelPositioningUtils() |
| Modifier and Type | Method and Description |
|---|---|
static MCoordinate |
alignAccordingToAngle(MBoundingBox boundingRect,
double angleDeg)
This method takes the given bounding rectangle and shifts it according to
the given angle so that:
If the angle is 0-90 the lower left corner of the rectangle is on the original position. |
static MCoordinate |
getAutoPlacementToCircle(double angleDeg,
java.awt.Font font,
java.lang.String text,
double baseDistance)
Determines relative coordinates of a label placed within certain distance
from the base and at the given angle.
|
static MCoordinate |
getAutoPlacementToRectangle(double angleDeg,
MBoundingBox rectangle,
java.awt.Font font,
java.lang.String text)
Determines relative coordinates of a label placed on a circumference of a
(bounding) rectangle at the given angle.
|
static MCoordinate |
getLabelDimensions(java.lang.String text,
java.awt.Font font)
Calculates the dimensions of the given text using the give font.
|
public static MCoordinate getAutoPlacementToCircle(double angleDeg, java.awt.Font font, java.lang.String text, double baseDistance)
angleDeg
- The angle in degrees relative to the x-axis in the
positive direction with the origin in the label base
coordinatesfont
- The font of the labeltext
- The text of the label. If the text is null
empty
string ("") will be used instead.baseDistance
- The distance at which the label should be from the
base coordinate. This method will make sure that the label is
NEVER within this circle and always has some extra small space
(so it is not touching the bounding circle).public static MCoordinate getAutoPlacementToRectangle(double angleDeg, MBoundingBox rectangle, java.awt.Font font, java.lang.String text)
angleDeg
- The angle in degrees relative to the x-axis in the
positive direction with the origin in the label base
coordinatesfont
- The font of the labeltext
- The text of the label. If the text is null
empty
string ("") will be used instead.rectangle
- The rectangle to which the label should be alignedpublic static MCoordinate getLabelDimensions(java.lang.String text, java.awt.Font font)
text
- The text of the label. If null
, then empty
string will be used.font
- The font of the label. If null
, then the default
font will be used.MCoordinate
public static MCoordinate alignAccordingToAngle(MBoundingBox boundingRect, double angleDeg)
boundingRect
- The bounding rectangle of the object, most likely the
labelangleDeg
- The angle at which the bounding rectangle should be
positionedgetAutoPlacement
method.


# %%
# Graphein
# Author: Arian Jamasb<EMAIL_ADDRESS>Eric Ma
# License: MIT
# Project Website: https://github.com/a-r-j/graphein
# Code Repository: https://github.com/a-r-j/graphein
# TODO: This the docstrings inside this module's set of functions
# can do without the `type`s.
# This is because the types are already annotated on the function.
import logging
from functools import partial
from typing import Any, Callable, Dict, List, Optional
import networkx as nx
from graphein.protein.features.sequence.utils import (
aggregate_feature_over_chains,
compute_feature_over_chains,
)
from graphein.protein.features.utils import (
aggregate_graph_feature_over_chains,
convert_graph_dict_feat_to_series,
)
log = logging.getLogger(__name__)
[docs]def compute_propy_feature(
G: nx.Graph,
func: Callable,
feature_name: str,
aggregation_type: Optional[List[str]] = None,
) -> nx.Graph:
"""
Computes Propy Descriptors over chains in a Protein Graph
:param G: Protein Graph
:type G: nx.Graph
:param func: ProPy wrapper function to compute
:type func: Callable
:param feature_name: Name of feature to index it in the nx.Graph object
:type feature_name: str
:param aggregation_type: Type of aggregation to use when aggregating a feature over multiple chains. One of:
["mean", "man", "sum"]. Defaults to None.
:type aggregation_type: List[str], optional
:return G: Returns protein Graph with features added. Features are accessible with G.graph[{feature_name}_{chain | aggegation_type}]
:rtype: nx.Graph
"""
G = compute_feature_over_chains(G, func, feature_name=feature_name)
# Convert to Series
G = convert_graph_dict_feat_to_series(G, feature_name=feature_name)
# Aggregate features
if len(G.graph["chain_ids"]) > 1:
if aggregation_type:
G = aggregate_graph_feature_over_chains(
G, feature_name=feature_name, aggregation_type=aggregation_type
)
else:
log.debug("Aggregation not carried out on single-chain graph")
return G
[docs]def amino_acid_composition(
G: nx.Graph, aggregation_type: Optional[List[str]] = None
) -> nx.Graph:
"""
Calculate the composition of Amino acids for a given protein sequence.
:param G: Protein Graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use
:type aggregation_type: Optional[List[str]]
:return: Protein Graph with amino_acid_composition feature added. G.graph["amino_acid_composition_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.AAComposition import CalculateAAComposition
func = CalculateAAComposition
feature_name = "amino_acid_composition"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def dipeptide_composition(
G: nx.Graph, aggregation_type: Optional[List[str]] = None
) -> nx.Graph:
"""
Calculate the composition of dipeptidefor a given protein sequence. Contains composition of 400 dipeptides
:param G: Protein Graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with dipeptide_composition feature added. G.graph["dipeptide_composition_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.AAComposition import CalculateDipeptideComposition
func = CalculateDipeptideComposition
feature_name = "dipeptide_composition"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def aa_dipeptide_composition(
G: nx.Graph, aggregation_type: Optional[List[str]] = None
) -> nx.Graph:
"""
Calculate the composition of AADs, dipeptide and 3-mers for a given protein sequence. Contains all composition
values of AADs, dipeptide and 3-mers (8420).
:param G: Protein Graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with aa_dipeptide_composition feature added.
G.graph["aa_dipeptide_composition_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.AAComposition import CalculateAADipeptideComposition
func = CalculateAADipeptideComposition
feature_name = "aa_dipeptide_composition"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def aa_spectrum(
G: nx.Graph, aggregation_type: Optional[List[str]] = None
) -> nx.Graph:
"""
Calculate the spectrum descriptors of 3-mers for a given protein. Contains the composition values of 8000 3-mers
:param G: Protein Graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with aa_spectrum feature added. G.graph["aa_spectrum_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.AAComposition import GetSpectrumDict
func = GetSpectrumDict
feature_name = "aa_spectrum"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
######## CTD Funcs #######
[docs]def all_composition_descriptors(
G: nx.Graph, aggregation_type: Optional[List[str]] = None
) -> nx.Graph:
"""
Calculate all composition descriptors based on seven different properties of AADs.
:param G: Protein Graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with composition_descriptors feature added.
G.graph["composition_descriptors_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateC
func = CalculateC
feature_name = "composition_descriptors"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def all_ctd_descriptors(
G: nx.Graph, aggregation_type: Optional[List[str]] = None
) -> nx.Graph:
"""
Calculate all CTD descriptors based seven different properties of AADs.
:param G: Protein Graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with ctd_descriptors feature added.
G.graph["ctd_descriptors_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateCTD
func = CalculateCTD
feature_name = "ctd_descriptors"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def composition_descriptor(
G: nx.Graph,
AAProperty: Dict[Any, Any],
AAPName: str,
aggregation_type: Optional[List[str]] = None,
) -> nx.Graph:
"""
Compute composition descriptors.
:param G: Protein Graph to featurise
:type G: nx.Graph
:param AAProperty: contains classification of amino acids such as _Polarizability.
:type AAProperty: Dict[Any, Any]
:param AAPName: used for indicating a AAP name.
:type AAPName: str
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with composition_{AAPName} feature added.
G.graph["composition_{AAPName}_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateComposition
func = partial(
CalculateComposition, AAProperty=AAProperty, AAPName=AAPName
)
feature_name = f"composition_{AAPName}"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def composition_charge(
G: nx.Graph, aggregation_type: Optional[List[str]] = None
) -> nx.Graph:
"""
Calculate composition descriptors based on Charge of AADs.
:param G: Protein Graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with composition_charge feature added.
G.graph["composition_charge_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateCompositionCharge
func = CalculateCompositionCharge
feature_name = "composition_charge"
G = compute_feature_over_chains(G, func, feature_name="composition_charge")
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def composition_hydrophobicity(
G: nx.Graph, aggregation_type: Optional[List[str]] = None
) -> nx.Graph:
"""
Calculate composition descriptors based on Hydrophobicity of AADs.
:param G: Protein Graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with composition_hydrophobicity feature added.
G.graph["composition_hydrophobicity_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateCompositionHydrophobicity
func = CalculateCompositionHydrophobicity
feature_name = "composition_hydrophobicity"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def composition_normalized_vdwv(
G: nx.Graph, aggregation_type: Optional[List[str]] = None
) -> nx.Graph:
"""
Calculate composition descriptors based on NormalizedVDWV of AADs.
:param G: Protein Graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with composition_normalized_vdwv feature added.
G.graph["composition_normalized_vdwv_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateCompositionNormalizedVDWV
func = CalculateCompositionNormalizedVDWV
feature_name = "composition_normalised_vdwv"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def composition_polarity(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate composition descriptors based on Polarity of AADs.
:param G: Protein Graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with composition_polarity feature added.
G.graph["composition_polarity_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateCompositionPolarity
func = CalculateCompositionPolarity
feature_name = "composition_polarity"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def composition_polarizability(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate composition descriptors based on Polarizability of AADs.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with composition_polarizability feature added.
G.graph["composition_polarizability_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateCompositionPolarizability
func = CalculateCompositionPolarizability
feature_name = "composition_polarizability"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def composition_secondary_str(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate composition descriptors based on SecondaryStr of AADs.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with composition_secondary_str feature added.
G.graph["composition_secondary_str_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateCompositionSecondaryStr
func = CalculateCompositionSecondaryStr
feature_name = "composition_secondary_str"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def composition_solvent_accessibility(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate composition descriptors based on SolventAccessibility of AADs.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with composition_solvent_accessibility feature added.
G.graph["composition_solvent_accessibility_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateCompositionSolventAccessibility
func = CalculateCompositionSolventAccessibility
feature_name = "composition_solvent_accessibility"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def all_distribution_descriptors(
G: nx.Graph, aggregation_type: Optional[List[str]] = None
) -> nx.Graph:
"""
Calculate all distribution descriptors based on seven different properties of AADs.
:param G: Protein Graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with distribution_descriptors feature added.
G.graph["distribution_descriptors_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateC
func = CalculateC
feature_name = "distribution_descriptors"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def distribution_descriptor(
G: nx.Graph,
AAProperty: Dict[Any, Any],
AAPName: str,
aggregation_type: Optional[List[str]] = None,
) -> nx.Graph:
"""
Compute distribution descriptors.
:param G: Protein Graph to featurise
:type G: nx.Graph
:param AAProperty: contains classifciation of amino acids such as _Polarizability.
:type AAProperty: Dict[Any, Any]
:param AAPName: used for indicating a AAP name.
:type AAPName: str
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with distribution_{AAPName} feature added.
G.graph["distribution_{AAPName}_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateDistribution
func = partial(
CalculateDistribution, AAProperty=AAProperty, AAPName=AAPName
)
feature_name = f"distribution_{AAPName}"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def distribution_charge(
G: nx.Graph, aggregation_type: Optional[List[str]] = None
) -> nx.Graph:
"""
Calculate distribution descriptors based on Charge of AADs.
:param G: Protein Graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with distribution_charge feature added.
G.graph["distribution_charge_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateDistributionCharge
func = CalculateDistributionCharge
feature_name = "distribution_charge"
G = compute_feature_over_chains(
G, func, feature_name="distribution_charge"
)
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def distribution_hydrophobicity(
G: nx.Graph, aggregation_type: Optional[List[str]] = None
) -> nx.Graph:
"""
Calculate distribution descriptors based on Hydrophobicity of AADs.
:param G: Protein Graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with distribution_hydrophobicity feature added.
G.graph["distribution_hydrophobicity_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateDistributionHydrophobicity
func = CalculateDistributionHydrophobicity
feature_name = "distribution_hydrophobicity"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def distribution_normalized_vdwv(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate distribution descriptors based on NormalizedVDWV of AADs.
:param G: Protein Graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with distribution_normalized_vdwv feature added.
G.graph["distribution_normalized_vdwv_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateDistributionNormalizedVDWV
func = CalculateDistributionNormalizedVDWV
feature_name = "distribution_normalised_vdwv"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def distribution_polarity(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate distribution descriptors based on Polarity of AADs.
:param G: Protein Graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with distribution_polarity feature added.
G.graph["distribution_polarity_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateDistributionPolarity
func = CalculateDistributionPolarity
feature_name = "distribution_polarity"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def distribution_polarizability(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate distribution descriptors based on Polarizability of AADs.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with distribution_polarizability feature added.
G.graph["distribution_polarizability_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateDistributionPolarizability
func = CalculateDistributionPolarizability
feature_name = "distribution_polarizability"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def distribution_secondary_str(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate distribution descriptors based on SecondaryStr of AADs.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with distribution_secondary_str feature added.
G.graph["distribution_secondary_str_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateDistributionSecondaryStr
func = CalculateDistributionSecondaryStr
feature_name = "distribution_secondary_str"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def distribution_solvent_accessibility(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate distribution descriptors based on SolventAccessibility of AADs.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with distribution_solvent_accessibility feature added.
G.graph["distribution_solvent_accessibility_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateDistributionSolventAccessibility
func = CalculateDistributionSolventAccessibility
feature_name = "distribution_solvent_accessibility"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def all_transition_descriptors(
G: nx.Graph, aggregation_type: Optional[List[str]] = None
) -> nx.Graph:
"""
Calculate all transition descriptors based on seven different properties of AADs.
:param G: Protein Graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with transition_descriptors feature added.
G.graph["transition_descriptors_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateC
func = CalculateC
feature_name = "transition_descriptors"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def transition_descriptor(
G: nx.Graph,
AAProperty: Dict[Any, Any],
AAPName: str,
aggregation_type: Optional[List[str]] = None,
) -> nx.Graph:
"""
Compute transition descriptors.
:param G: Protein Graph to featurise
:type G: nx.Graph
:param AAProperty: contains classifciation of amino acids such as _Polarizability.
:type AAProperty: Dict[Any, Any]
:param AAPName: used for indicating a AAP name.
:type AAPName: str
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with transition_{AAPName} feature added.
G.graph["transition_{AAPName}_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateTransition
func = partial(CalculateTransition, AAProperty=AAProperty, AAPName=AAPName)
feature_name = f"transition_{AAPName}"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def transition_charge(
G: nx.Graph, aggregation_type: Optional[List[str]] = None
) -> nx.Graph:
"""
Calculate transition descriptors based on Charge of AADs.
:param G: Protein Graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with transition_charge feature added.
G.graph["transition_charge_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateTransitionCharge
func = CalculateTransitionCharge
feature_name = "transition_charge"
G = compute_feature_over_chains(G, func, feature_name="transition_charge")
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def transition_hydrophobicity(
G: nx.Graph, aggregation_type: Optional[List[str]] = None
) -> nx.Graph:
"""
Calculate transition descriptors based on Hydrophobicity of AADs.
:param G: Protein Graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with transition_hydrophobicity feature added.
G.graph["transition_hydrophobicity_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateTransitionHydrophobicity
func = CalculateTransitionHydrophobicity
feature_name = "transition_hydrophobicity"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def transition_normalized_vdwv(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate transition descriptors based on NormalizedVDWV of AADs.
:param G: Protein Graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with transition_normalized_vdwv feature added.
G.graph["transition_normalized_vdwv_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateTransitionNormalizedVDWV
func = CalculateTransitionNormalizedVDWV
feature_name = "transition_normalised_vdwv"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def transition_polarity(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate transition descriptors based on Polarity of AADs.
:param G: Protein Graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with transition_polarity feature added.
G.graph["transition_polarity_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateTransitionPolarity
func = CalculateTransitionPolarity
feature_name = "transition_polarity"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def transition_polarizability(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate transition descriptors based on Polarizability of AADs.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with transition_polarizability feature added.
G.graph["transition_polarizability_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateTransitionPolarizability
func = CalculateTransitionPolarizability
feature_name = "transition_polarizability"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def transition_secondary_str(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate transition descriptors based on SecondaryStr of AADs.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with transition_secondary_str feature added.
G.graph["transition_secondary_str_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateTransitionSecondaryStr
func = CalculateTransitionSecondaryStr
feature_name = "transition_secondary_str"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def transition_solvent_accessibility(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate transition descriptors based on SolventAccessibility of AADs.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with transition_solvent_accessibility feature added.
G.graph["transition_solvent_accessibility_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.CTD import CalculateTransitionSolventAccessibility
func = CalculateTransitionSolventAccessibility
feature_name = "transition_solvent_accessibility"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
####### Autocorrelation descriptors ########
[docs]def autocorrelation_total(
G: nx.Graph, aggregation_type: Optional[List[str]] = None
) -> nx.Graph:
"""
Compute all autocorrelation descriptors based on 8 properties of AADs. result contains 30*8*3=720 normalized Moreau
Broto, Moran, and Geary
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_total feature added.
G.graph["autocorrelation_total_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import CalculateAutoTotal
func = CalculateAutoTotal
feature_name = "autocorrelation_total"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_geary_all(
G: nx.Graph, aggregation_type: Optional[List[str]] = None
) -> nx.Graph:
"""
Compute Geary autocorrelation descriptors based on 8 properties of AADs. Result contains 30*8=240 Geary
autocorrelation descriptors based on the given properties(i.e., _AAPropert).
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_geary_all feature added.
G.graph["autocorrelation_geary_all_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import CalculateGearyAutoTotal
func = CalculateGearyAutoTotal
feature_name = "autocorrelation_geary_all"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_geary_av_flexibility(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the Geary Autocorrelation descriptors based on AvFlexibility. contains 30 Geary Autocorrelation
descriptors based on AvFlexibility.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_geary_av_flexibility feature added.
G.graph["autocorrelation_geary_av_flexibility_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import CalculateGearyAutoAvFlexibility
func = CalculateGearyAutoAvFlexibility
feature_name = "autocorrelation_geary_av_flexibility"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_geary_free_energy(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the Geary Autocorrelation descriptors based on FreeEnergy. result contains 30 Geary Autocorrelation
descriptors based on FreeEnergy.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_geary_free_energy feature added.
G.graph["autocorrelation_geary_av_free_energy_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import CalculateGearyAutoFreeEnergy
func = CalculateGearyAutoFreeEnergy
feature_name = "autocorrelation_geary_free_energy"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_geary_hydrophobicity(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the Geary Autocorrelation descriptors based on hydrophobicity. result contains 30 Geary Autocorrelation
descriptors based on hydrophobicity.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_geary_hydrophobicity feature added.
G.graph["autocorrelation_geary_hydrophobicity_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import CalculateGearyAutoHydrophobicity
func = CalculateGearyAutoHydrophobicity
feature_name = "autocorrelation_geary_hydrophobicity"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_geary_mutability(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the Geary Autocorrelation descriptors based on Mutability. result contains 30 Geary Autocorrelation
descriptors based on mutability.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_geary_mutability feature added.
G.graph["autocorrelation_geary_mutability_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import CalculateGearyAutoMutability
func = CalculateGearyAutoMutability
feature_name = "autocorrelation_geary_mutability"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_geary_polarizability(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the Geary Autocorrelation descriptors based on polarizability. result contains 30 Geary Autocorrelation
descriptors based on polarizability.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_geary_polarizability feature added.
G.graph["autocorrelation_geary_polarizability_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import CalculateGearyAutoPolarizability
func = CalculateGearyAutoPolarizability
feature_name = "autocorrelation_geary_polarizability"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_geary_residue_asa(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the Geary Autocorrelation descriptors based on ResidueASA. result contains 30 Geary Autocorrelation
descriptors based on ResidueASA.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_geary_residue_asa feature added.
G.graph["autocorrelation_geary_residue_asa_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import CalculateGearyAutoResidueASA
func = CalculateGearyAutoResidueASA
feature_name = "autocorrelation_geary_residue_asa"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_geary_residue_vol(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the Geary Autocorrelation descriptors based on ResidueVol. result contains 30 Geary Autocorrelation
descriptors based on ResidueVol.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_geary_residue_vol feature added.
G.graph["autocorrelation_geary_residue_vol_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import CalculateGearyAutoResidueVol
func = CalculateGearyAutoResidueVol
feature_name = "autocorrelation_geary_residue_vol"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_geary_steric(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the Geary Autocorrelation descriptors based on Steric. result contains 30 Geary Autocorrelation
descriptors based on Steric
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_geary_steric feature added.
G.graph["autocorrelation_geary_steric_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import CalculateGearyAutoSteric
func = CalculateGearyAutoSteric()
feature_name = "autocorrelation_geary_steric"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_moran_all(
G: nx.Graph, aggregation_type: Optional[List[str]] = None
) -> nx.Graph:
"""
Compute Moran autocorrelation descriptors based on 8 properties of AADs. Result contains 30*8=240 Moran
autocorrelation descriptors based on the given properties(i.e., _AAPropert).
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_moran_all feature added.
G.graph["autocorrelation_moran_all_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import CalculateMoranAutoTotal
func = CalculateMoranAutoTotal
feature_name = "autocorrelation_moran_all"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_moran_av_flexibility(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the Moran Autocorrelation descriptors based on AvFlexibility. contains 30 Moran Autocorrelation
descriptors based on AvFlexibility.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_moran_av_flexibility feature added.
G.graph["autocorrelation_moran_av_flexibility_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import CalculateMoranAutoAvFlexibility
func = CalculateMoranAutoAvFlexibility
feature_name = "autocorrelation_moran_av_flexibility"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_moran_free_energy(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the Moran Autocorrelation descriptors based on FreeEnergy. result contains 30 Moran Autocorrelation
descriptors based on FreeEnergy.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_moran_free_energy feature added.
G.graph["autocorrelation_moran_av_free_energy_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import CalculateMoranAutoFreeEnergy
func = CalculateMoranAutoFreeEnergy
feature_name = "autocorrelation_moran_free_energy"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_moran_hydrophobicity(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the Moran Autocorrelation descriptors based on hydrophobicity. result contains 30 Moran Autocorrelation
descriptors based on hydrophobicity.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_moran_hydrophobicity feature added.
G.graph["autocorrelation_moran_hydrophobicity_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import CalculateMoranAutoHydrophobicity
func = CalculateMoranAutoHydrophobicity
feature_name = "autocorrelation_moran_hydrophobicity"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_moran_mutability(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the Moran Autocorrelation descriptors based on Mutability. result contains 30 Moran Autocorrelation
descriptors based on mutability.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_moran_mutability feature added.
G.graph["autocorrelation_moran_mutability_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import CalculateMoranAutoMutability
func = CalculateMoranAutoMutability
feature_name = "autocorrelation_moran_mutability"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_moran_polarizability(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the Moran Autocorrelation descriptors based on polarizability. result contains 30 Moran Autocorrelation
descriptors based on polarizability.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_moran_polarizability feature added.
G.graph["autocorrelation_moran_polarizability_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import CalculateMoranAutoPolarizability
func = CalculateMoranAutoPolarizability
feature_name = "autocorrelation_moran_polarizability"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_moran_residue_asa(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the Moran Autocorrelation descriptors based on ResidueASA. result contains 30 Moran Autocorrelation
descriptors based on ResidueASA.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_moran_residue_asa feature added.
G.graph["autocorrelation_moran_residue_asa_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import CalculateMoranAutoResidueASA
func = CalculateMoranAutoResidueASA
feature_name = "autocorrelation_moran_residue_asa"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_moran_residue_vol(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the Moran Autocorrelation descriptors based on ResidueVol. result contains 30 Moran Autocorrelation
descriptors based on ResidueVol.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_moran_residue_vol feature added.
G.graph["autocorrelation_moran_residue_vol_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import CalculateMoranAutoResidueVol
func = CalculateMoranAutoResidueVol
feature_name = "autocorrelation_moran_residue_vol"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_moran_steric(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the Moran Autocorrelation descriptors based on Steric. result contains 30 Moran Autocorrelation
descriptors based on Steric
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_moran_steric feature added.
G.graph["autocorrelation_moran_steric_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import CalculateMoranAutoSteric
func = CalculateMoranAutoSteric()
feature_name = "autocorrelation_moran_steric"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_normalized_moreau_broto_all(
G: nx.Graph, aggregation_type: Optional[List[str]] = None
) -> nx.Graph:
"""
Compute NormalizedMoreauBroto autocorrelation descriptors based on 8 properties of AADs. Result contains 30*8=240
NormalizedMoreauBroto autocorrelation descriptors based on the given properties(i.e., _AAPropert).
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_normalized_moreau_broto_all feature added.
G.graph["autocorrelation_normalized_moreau_broto_all_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import CalculateNormalizedMoreauBrotoAutoTotal
func = CalculateNormalizedMoreauBrotoAutoTotal
feature_name = "autocorrelation_normalized_moreau_broto_all"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_normalized_moreau_broto_av_flexibility(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the NormalizedMoreauBroto Autocorrelation descriptors based on AvFlexibility. contains 30
NormalizedMoreauBroto Autocorrelation descriptors based on AvFlexibility.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_normalized_moreau_broto_av_flexibility feature added.
G.graph["autocorrelation_normalized_moreau_broto_av_flexibility_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import (
CalculateNormalizedMoreauBrotoAutoAvFlexibility,
)
func = CalculateNormalizedMoreauBrotoAutoAvFlexibility
feature_name = "autocorrelation_normalized_moreau_broto_av_flexibility"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_normalized_moreau_broto_free_energy(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the NormalizedMoreauBroto Autocorrelation descriptors based on FreeEnergy. result contains 30
NormalizedMoreauBroto Autocorrelation descriptors based on FreeEnergy.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_normalized_moreau_broto_free_energy feature added.
G.graph["autocorrelation_normalized_moreau_broto_av_free_energy_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import (
CalculateNormalizedMoreauBrotoAutoFreeEnergy,
)
func = CalculateNormalizedMoreauBrotoAutoFreeEnergy
feature_name = "autocorrelation_normalized_moreau_broto_free_energy"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_normalized_moreau_broto_hydrophobicity(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the NormalizedMoreauBroto Autocorrelation descriptors based on hydrophobicity. result contains 30
NormalizedMoreauBroto Autocorrelation descriptors based on hydrophobicity.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_normalized_moreau_broto_hydrophobicity feature added.
G.graph["autocorrelation_normalized_moreau_broto_hydrophobicity_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import (
CalculateNormalizedMoreauBrotoAutoHydrophobicity,
)
func = CalculateNormalizedMoreauBrotoAutoHydrophobicity
feature_name = "autocorrelation_normalized_moreau_broto_hydrophobicity"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_normalized_moreau_broto_mutability(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the NormalizedMoreauBroto Autocorrelation descriptors based on Mutability. result contains 30
NormalizedMoreauBroto Autocorrelation descriptors based on mutability.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_normalized_moreau_broto_mutability feature added.
G.graph["autocorrelation_normalized_moreau_broto_mutability_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import (
CalculateNormalizedMoreauBrotoAutoMutability,
)
func = CalculateNormalizedMoreauBrotoAutoMutability
feature_name = "autocorrelation_normalized_moreau_broto_mutability"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_normalized_moreau_broto_polarizability(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the NormalizedMoreauBroto Autocorrelation descriptors based on polarizability. result contains 30
NormalizedMoreauBroto Autocorrelation descriptors based on polarizability.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_normalized_moreau_broto_polarizability feature added.
G.graph["autocorrelation_normalized_moreau_broto_polarizability_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import (
CalculateNormalizedMoreauBrotoAutoPolarizability,
)
func = CalculateNormalizedMoreauBrotoAutoPolarizability
feature_name = "autocorrelation_normalized_moreau_broto_polarizability"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_normalized_moreau_broto_residue_asa(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the NormalizedMoreauBroto Autocorrelation descriptors based on ResidueASA. result contains 30
NormalizedMoreauBroto Autocorrelation descriptors based on ResidueASA.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_normalized_moreau_broto_residue_asa feature added.
G.graph["autocorrelation_normalized_moreau_broto_residue_asa_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import (
CalculateNormalizedMoreauBrotoAutoResidueASA,
)
func = CalculateNormalizedMoreauBrotoAutoResidueASA
feature_name = "autocorrelation_normalized_moreau_broto_residue_asa"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_normalized_moreau_broto_residue_vol(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the NormalizedMoreauBroto Autocorrelation descriptors based on ResidueVol. result contains 30
NormalizedMoreauBroto Autocorrelation descriptors based on ResidueVol.
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_normalized_moreau_broto_residue_vol feature added.
G.graph["autocorrelation_normalized_moreau_broto_residue_vol_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import (
CalculateNormalizedMoreauBrotoAutoResidueVol,
)
func = CalculateNormalizedMoreauBrotoAutoResidueVol
feature_name = "autocorrelation_normalized_moreau_broto_residue_vol"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
[docs]def autocorrelation_normalized_moreau_broto_steric(
G: nx.Graph, aggregation_type: Optional[List[str]]
) -> nx.Graph:
"""
Calculate the NormalizedMoreauBroto Autocorrelation descriptors based on Steric. result contains 30
NormalizedMoreauBroto Autocorrelation descriptors based on Steric
:param G: Protein graph to featurise
:type G: nx.Graph
:param aggregation_type: Aggregation types to use over chains
:type aggregation_type: List[Optional[str]]
:return: Protein Graph with autocorrelation_normalized_moreau_broto_steric feature added.
G.graph["autocorrelation_normalized_moreau_broto_steric_{chain | aggregation_type}"]
:rtype: nx.Graph
"""
from propy.Autocorrelation import CalculateNormalizedMoreauBrotoAutoSteric
func = CalculateNormalizedMoreauBrotoAutoSteric()
feature_name = "autocorrelation_normalized_moreau_broto_steric"
return compute_propy_feature(
G,
func=func,
feature_name=feature_name,
aggregation_type=aggregation_type,
)
####### Quasi Sequence Order Descriptors ######
def quasi_sequence_order_aa_composition(G: nx.Graph) -> nx.Graph:
from propy.QuasiSequenceOrder import GetAAComposition
func = GetAAComposition
G = compute_feature_over_chains(
G, func, feature_name="quasi_seq_order_aa_composition"
)
return G
[docs]def quasi_sequence_order(
G: nx.Graph, maxlag: int = 30, weight: float = 0.1
) -> nx.Graph:
"""
Compute quasi-sequence-order descriptors for a given protein.
Kuo-Chen Chou. Prediction of Protein Subcellar Locations by Incorporating Quasi-Sequence-Order Effect.
Biochemical and Biophysical Research Communications 2000, 278, 477-483.
:param maxlag: (int, optional (default: 30)) – the maximum lag and the length of the protein should be larger than
maxlag
:type maxlag: int
:param weight: (float, optional (default: 0.1)) – a weight factor. Please see reference 1 for its choice.
:type weight: float
:returns:
:rtype: nx.Graph
"""
from propy.QuasiSequenceOrder import GetQuasiSequenceOrder
func = partial(GetQuasiSequenceOrder, weight=weight, maxlag=maxlag)
G = compute_feature_over_chains(
G, func, feature_name="quasi_sequence_order"
)
return G
[docs]def sequence_order_coupling_number_total(
G: nx.Graph, maxlag: int = 30
) -> nx.Graph:
"""
Compute the sequence order coupling numbers from 1 to maxlag for a given protein sequence.
:param G: Protein Graph
:type G: nx.Graph
:param maxlag (int, optional (default: 30)) – the maximum lag and the length of the protein should be larger
:type maxlag: int
:returns:
:rtype: nx.Graph
"""
from propy.QuasiSequenceOrder import GetSequenceOrderCouplingNumberTotal
func = partial(GetSequenceOrderCouplingNumberTotal, maxlag=maxlag)
G = compute_feature_over_chains(
G, func, feature_name="sequence_order_coupling_number_total"
)
return G
# Todo feature aggregation
if __name__ == "__main__":
pass


THE IRON YARD | HOUSTON
Happenings and updates from The Iron Yard in Houston, TX
SEARCH
September 22 Starts a New Class of The Iron Yard Houston Students
By Brian Dorton, Campus Director at The Iron Yard Houston
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Dolor dicta est sequi numquam, reiciendis, laborum quaerat sed eos error veritatis repudiandae natus ratione. Non consequuntur, consequatur vitae unde debitis recusandae!


MEMMEM
Section: Linux Programmer's Manual (3)
Updated: 2014-08-19
Index
Return to Main Contents
NAME
memmem - locate a substring
SYNOPSIS
#define _GNU_SOURCE /* See feature_test_macros(7) */
#include <string.h>
void *memmem(const void *haystack, size_t haystacklen,
const void *needle, size_t needlelen);
DESCRIPTION
The
memmem()
function finds the start of the first occurrence
of the substring
needle
of length
needlelen
in the memory
area
haystack
of length
haystacklen.
RETURN VALUE
The
memmem()
function returns a pointer to the beginning of the
substring, or NULL if the substring is not found.
ATTRIBUTES
Multithreading (see pthreads(7))
The
memmem()
function is thread-safe.
CONFORMING TO
This function is a GNU extension.
BUGS
In glibc 2.0, if
needle
is empty,
memmem()
returns a pointer to the last byte of
haystack.
This is fixed in glibc 2.1.
SEE ALSO
strstr(3)
Index
- NAME
-
- SYNOPSIS
-
- DESCRIPTION
-
- RETURN VALUE
-
- ATTRIBUTES
-
- Multithreading (see pthreads(7))
-
- CONFORMING TO
-
- BUGS
-
- SEE ALSO
-
This document was created by
man2html,
using the manual pages.
Time: 02:55:03 GMT, September 18, 2014


[1]
definitely needed more umbrellas for shade near the pool floaties etc.
[2]
but make sure you know it is no worse than market.


Portfolio
A visionary company with a high demand for patient care!
1000 pacients
in Year
Services
Consultation
R$ 120.00 / Hr
- +100 Profissionals in Plataform
- Vaccinated Professionals
- Feel good or your money back
Consultation Online
R$ 80.00/ Hr
- +100 Profissionals in Plataform
- Proper Plataform
- Feel good or your money back
Consultation Presential
R$ 180.00 / Hr
- +100 Profissionals in Plataform
- Vaccinated Professionals
- Feel good or your money back
Partners/Customers
About
The statistics of people with anxiety and stress are increasing, but in quarantine it got much worse. The average of people with anxiety in the world during quarantine, according to Agência Brasil (Brazil Agency), the rate is 30% and it's still on a big increase. But in some countries like Brazil, the situation has worsened even more, statistics show that approximately 80% of the population reported having varied symptoms of anxiety.
As a solution to these serious problems during a time of social isolation, we created virtual services to contact patients and carry out consultations, both face-to-face and virtual. So with the use of the internet during the quarantine, it allowed us to get in touch with several people, to prevent new situations from occurring or worsening in relation to anxiety, stress, depression and other disorders.
With virtual assistance through our platform, it is more accessible for many people to schedule their medical appointments and makes it more comprehensive for the client to choose how they want to be attended.


data-toggle="industrypicker"
<div data-toggle="industrypicker"> <select></select> <select></select> <select></select> </div>


{{beforeContent}}
Read More
{{afterContent}}
Read More
Upload your document, choose the save format type and click on “Convert” button. You will get the download link as soon as the file is converted.
It works from all platforms including Windows, Mac, Android and iOS. All files are processed on our servers. No plugin or software installation required for you.
Powered by Aspose.3D. All files are processed using Aspose APIs, which are being used by many Fortune 100 companies across 114 countries.
You can also convert {{beforeSuffix}} into many other file formats. Please see the complete list below.


open kadamwhite/wordpress-rest-api#118
Re: #117, @brad-decker indicates around supporting array filters:
You also need to add post__in and post__not_in to query_vars on your wordpress install.
post__in
post__not_in
query_vars
This should be addressed in the readme or API documentation.
Re: #117, @brad-decker indicates around supporting array filters:
This should be addressed in the readme or API documentation.


|
RL-Bin
2.0.0
Robust Low-overhead Binary Rewriter
|
class that keeps the data structure for disassmebly table More...
Public Member Functions | |
| ~DisTable (void) | |
| void | Initialize (SIZE_TYPE _size) |
| sets all the table entries to undiscovered More... | |
| void | SetEntry (ADDRESS _address, CELL _value) |
| sets the entry at _address to _value More... | |
| CELL | GetEntry (ADDRESS _address) |
| gets the entry at _address More... | |
Static Public Member Functions | |
| static DisTable * | Create (void) |
| Creates the one and only instance of DisTable class. More... | |
| static DisTable * | Get (void) |
| Gets the one and only instance of DisTable class. More... | |
Private Attributes | |
| SIZE_TYPE | size |
| CELL * | table |
Static Private Attributes | |
| static DisTable * | s_instance = NULL |
class that keeps the data structure for disassmebly table
Definition at line 16 of file DisTable.h.
| DisTable::~DisTable | ( | void | ) |
Default destructor of the DisTable class
Definition at line 49 of file DisTable.cpp.
|
static |
Creates the one and only instance of DisTable class.
Definition at line 11 of file DisTable.cpp.
|
static |
Gets the one and only instance of DisTable class.
Definition at line 22 of file DisTable.cpp.
gets the entry at _address
| [in] | _address | The address of the entry to be get |
Definition at line 70 of file DisTable.cpp.
| void DisTable::Initialize | ( | SIZE_TYPE | _size | ) |
sets all the table entries to undiscovered
| [in] | _size | The size of the table |
Definition at line 32 of file DisTable.cpp.
sets the entry at _address to _value
| [in] | _address | The address of the entry to be set |
| [in] | _value | The new value of the coresponding entry |
Definition at line 56 of file DisTable.cpp.
|
staticprivate |
The single unique object of this class
Definition at line 67 of file DisTable.h.
|
private |
size of the disassembly table
Definition at line 61 of file DisTable.h.
|
private |
table which is dynamic array of cell
Definition at line 64 of file DisTable.h.


Coach Features
Supported Algorithms
Coach supports many state-of-the-art reinforcement learning algorithms, which are separated into two main classes - value optimization and policy optimization. A detailed description of those algorithms may be found in the algorithms section.
Supported Environments
Coach supports a large number of environments which can be solved using reinforcement learning:
-
DeepMind Control Suite - a set of reinforcement learning environments powered by the MuJoCo physics engine.
-
Blizzard Starcraft II - a popular strategy game which was wrapped with a python interface by DeepMind.
-
ViZDoom - a Doom-based AI research platform for reinforcement learning from raw visual information.
-
CARLA - an open-source simulator for autonomous driving research.
-
OpenAI Gym - a library which consists of a set of environments, from games to robotics. Additionally, it can be extended using the API defined by the authors.
In Coach, we support all the native environments in Gym, along with several extensions such as:
-
Roboschool - a set of environments powered by the PyBullet engine, that offer a free alternative to MuJoCo.
-
Gym Extensions - a set of environments that extends Gym for auxiliary tasks (multitask learning, transfer learning, inverse reinforcement learning, etc.)
-
PyBullet - a physics engine that includes a set of robotics environments.


3.0 – Ad Run: Concept
3.1 – Ad Run: Production
3.2 – Ad Run: Sprint A
3.3 – Ad Run: Sprint B
3.4 – Ad Run: Sprint C
3.5 – Summary Review
1.0 – Foundation: Kickoff
2.0 – Foundation: Message
3.0 –Foundation: Research
D.0 – Development: Planning
D.1 – Development: Infrastructure
D.2 – Development: Sprint 1
2.0 – Campaign: Concept
2.1 – Campaign: Design
2.2 – Campaign: Production
D.3 – Development: Sprint 2
D.4 – Development: Sprint 3
D.5 – Development: Sprint 4
D.6 – Development: Sprint 5
3.0 – Ad Run: Concept
3.1 – Ad Run: Production
3.2 – Ad Run: Sprint A
3.3 – Ad Run: Sprint B
3.4 – Ad Run: Sprint C
3.5 – Summary Review
1.0 – Foundation: Kickoff
2.0 – Foundation: Message
3.0 –Foundation: Research
2.0 – Campaign: Concept
2.1 – Campaign: Design
2.2 – Campaign: Production
3.0 – Ad Run: Concept
3.1 – Ad Run: Production
3.2 – Ad Run: Sprint A
3.3 – Ad Run: Sprint B
3.4 – Ad Run: Sprint C
3.5 – Summary Review
D.0 – Development: Planning
D.1 – Development: Infrastructure
D.2 –Development: Sprint 1
D.3 –Development: Sprint 2
D.4 –Development: Sprint 3
D.5 –Development: Sprint 4
D.6 –Development: Sprint 5
Please note, 50% deposits for each phase are payable at beginning of each phase. Totals do not include associated advertising spend, server setup or hosting fees, or applicable taxes.
• Server / DB Setup: Linode + Airtable
• Complete User / Login System
+ Base System Flow (Owner Focus):
Site
Home Page
Owner Landing Page
Owner
• Sign-up
• Profile P1
Owner
• Login
Owner
• Profile P2
Owner
• Password
Owner
• Profile P3
Owner
• Reset
Owner
Profile Page
+ Base System Flow (Buyer Focus):
Buyer
Home Page
Owner Landing Page
Buyer
• Sign-up
• Profile P1
Buyer
• Login
Buyer
• Profile P2
Buyer
• Password
Buyer
• Profile P3
Buyer
• Reset
Buyer
Profile Page
We will leverage our work on an existing project for coaches that has mapped out UX best practices for a profile-based marketplace system. This will allow us to fast-track the development process.
Tyler Harder is the founder and managing director of Maikai Digital. From the West coast of Canada, and residing for over 12 years in Tokyo, Tyler has directed the management and marketing of two C corporations, developed retail and digital strategy for online product launches, hospitality and tourism, and founded companies specializing in digital media marketing, app technologies, and luxury content production.
Tyler has worked extensively with both well known brands and hundreds of startup and medium sized business founders, and most enjoys bringing clarity in the expression of great ideas to small business and startup founders.
Kallah Maguire has worked in digital media for 10 years with both small personal brands and large multinational corporations. She has worked with Disney, Microsoft, MSN Lifestyle, Fashion’s Night Out, Tommy Hilfiger, Regus, and many more.
Kallah is also considered an Instagram Influencer with a following of 42K where she is able to regularly engage with her community, gain clients, network and even make new friends. She has contributed to articles for Tyra Banks, WhoWhatWear.com, and Aston Martin, and teaches social media workshops for small business owners as well as multinational corporations.
Kallah’s passion is building strong communities around brands, and creating the Know, Like & Trust factor, so that people aren't just followers, but become an engaged and connected community.
Laura Abeyta has a unique understanding of what it takes to build a business from scratch. As a serial entrepreneur, having owned and operated 3 of her own companies over the past 15 years, she has a compelling sense of launch marketing. Laura now works as a consultant for product launches, marketing strategy, collaborations and startups. Her main gift is taking companies from vision to reality with practical, actionable steps forward. In her retail capacity, Laura startup and ran a series of boutique fashion outlets and acted as a tastemaker to stars such as Julia Roberts, the cast of Entourage, Twilight, regular awards shows, and was featured regularly on E! News and In-Style magazine. Laura also co-founded Hearisee Films, producing Shooting Castro, a documentary film that ran on Discovery / Times channel for 5 years. Laura’s recent activities include organizing TedX in Canggu, Bali in 2018.
Justin is a creative thinker with a passion for colour, typography, and a hands-on approach. Justin’s extensive background in graphic design, brand + identity - from conceptual thinking to illustration - gives him a unique ability to create expressive imagery that balances functionality and style.
Sindy is an author and brand consultant with 7 years of experience. Originally from Germany, she has been travelling the world for 5 years and has had the opportunities to work with internationally successful coaches and entrepreneurs during this time.With her MA in skills development and gifted education and her BA in social work and psychology, she helps businesses develop healthy and productive dynamics. As an author, she helps entrepreneurs write and publish Amazon bestsellers.
Julia is a multi-skilled copywriter with over 5 years all round writing experience and an ability to translate client requirements into creative, compelling and high-converting copy. Proficient in the production of a variety of writing styles such as web content, emails, blogs and social media posts as well as being familiar with the use of Google Analytics and SEO tools. She is a dynamic and enthusiastic worker accustomed to meeting quick deadlines and is passionate about working alongside a team of other professionals to develop innovative ideas.


--- layout: post title: IANA IPv4 Exhaustion date: 2011-02-09 10:53:32.000000000 +01:00 categories: - linux tags: [] status: publish type: post published: true meta: _edit_last: '1' _wp_old_slug: '' author: ---
* IANA IPv4 Exhaustion
At a ceremony held on 3 February, 2011 the Internet Assigned
Numbers Authority (IANA) allocated the remaining last five /8s of
IPv4 address space to the Regional Internet Registries (RIRs) in
accordance with the Global Policy for the Allocation of the
Remaining IPv4 Address Space. With this action, the free pool of
available IPv4 addresses is now fully depleted. To read the full
text of this announcement please go to:
http://www.nro.net/news/ipv4-free-pool-depleted
* World IPv6 Day
Facebook, Google (NASDAQ: GOOG) and Yahoo (NASDAQ: YHOO), websites
with more than one billion combined visits each day, are joining
major content delivery networks Akamai (NASDAQ: AKAM) and
Limelight Networks (NASDAQ: LLNW), and the Internet Society, for
the first global-scale trial of the new Internet Protocol, IPv6.
On June 8, 2011, dubbed World IPv6 Day, participants will enable
IPv6 on their main services for 24 hours. Cisco, Juniper,
Hurricane Electric, and Bing have also announced their
participation.
http://isoc.org/wp/worldipv6day/
Hurricane Electric's open letter to Hurricane Electric Customers,
Partners and Managers of Interconnected Networks about World IPv6
Day.
http://he.net/news/Hurricane_Electric_Letter_Regarding_World_IPv6_Day.pdf
At Hurricane Electric, every day is an IPv6 day.
* IPv6 Deployment Growth
The global IPv6 routing table has passed 4000 IPv6 prefixes.
Of the 36820 networks in the world running BGP, the number running
IPv6 has increased to 3107, or 8.4 percent.
Source: http://bgp.he.net/ipv6-progress-report.cgi
* Hurricane Electric Updated Network Map
We've continued to expand our network.
Updated Network Map: http://he.net/HurricaneElectricNetworkMap.pdf
Hurricane Electric now has over 6000 BGP sessions with over 1600
IPv4 and IPv6 networks at 45 different exchange points in North
America, Europe, and Asia.


|
| Local Properties | ||
| Managed Object Types | Data Object Types | All Properties | All Methods |
Properties
| Name | Type | Description |
|---|---|---|
| attachmentStatus* | xsd:string |
The status indicating the state of virtual network adapter's attachment
to an opaque network.
See ManagedEntityStatus for possible values.
red indicates that the network adapter is not yet successfully attached to opaque network. This can happen if corresponding attachment port is missing in the kernel. green indicates that the network adapater is successfully attached to opaque network. Since vSphere API 6.7 |
| featureRequirement* | VirtualMachineFeatureRequirement[] |
These network adapter requirements must have equivalent capabilities
on the virtual switch in order to power on or migrate to the host.
Since vSphere API 6.7 |
| reservationStatus* | xsd:string |
The status indicating whether network reservation requirement is violated
or not on the virtual network adapter. See ManagedEntityStatus
for possible values.
red indicates that reservation specified on the virtual network adapter is not being fulfilled. This can happen if the reservation requested is greater than the available capacity reserved for virtual machine traffic on the host. green indicates that the reservation specified on the virtual network adapter is being fulfilled. Since vSphere API 5.5 |
| vmDirectPathGen2Active | xsd:boolean |
Flag to indicate whether VMDirectPath Gen 2 is active on this device.
If false, the reason(s) for inactivity will be provided in one or
more of vmDirectPathGen2InactiveReasonVm,
vmDirectPathGen2InactiveReasonOther,
and vmDirectPathGen2InactiveReasonExtended.
|
| vmDirectPathGen2InactiveReasonExtended* | xsd:string |
If vmDirectPathGen2Active is false, this property may
contain an explanation provided by the platform, beyond the reasons
(if any) enumerated in vmDirectPathGen2InactiveReasonVm
and/or vmDirectPathGen2InactiveReasonOther.
|
| vmDirectPathGen2InactiveReasonOther* | xsd:string[] |
If vmDirectPathGen2Active is false, this array will be
populated with reasons for the inactivity that are not related to
virtual machine state or configuration (chosen from
VmDirectPathGen2InactiveReasonOther). Virtual machine
related reasons for inactivity will be provided in
vmDirectPathGen2InactiveReasonVm. If there is a reason
for inactivity that cannot be described by the available constants,
vmDirectPathGen2InactiveReasonExtended will be populated
with an additional explanation provided by the platform.
Note that this list of reasons is not guaranteed to be exhaustive. |
| vmDirectPathGen2InactiveReasonVm* | xsd:string[] |
If vmDirectPathGen2Active is false, this array will be
populated with reasons for the inactivity that are related to virtual
machine state or configuration (chosen from
VmDirectPathGen2InactiveReasonVm). Other reasons for
inactivity will be provided in
vmDirectPathGen2InactiveReasonOther. If there is a reason
for inactivity that cannot be described by the available constants,
vmDirectPathGen2InactiveReasonExtended will be populated
with an additional explanation provided by the platform.
Note that this list of reasons is not guaranteed to be exhaustive.
|
| Properties inherited from VirtualMachineDeviceRuntimeInfoDeviceRuntimeState | ||
| None | ||
| Properties inherited from DynamicData | ||
| None |
| Top of page | Local Properties | ||
| Managed Object Types | Data Object Types | All Properties | All Methods |


|
|
ACPISDTHeader | header |
| |
|
uint32_t | FirmwareCtrl |
| |
|
uint32_t | DSDTAddr |
| |
|
uint8_t | Reserved1 |
| |
|
uint8_t | PreferredPmProfile |
| |
|
uint16_t | SciInt |
| |
|
uint32_t | SmiCmd |
| |
|
uint8_t | AcpiEnable |
| |
|
uint8_t | AcpiDisable |
| |
|
uint8_t | S4BiosReq |
| |
|
uint8_t | PsateCnt |
| |
|
uint32_t | Pm1aEvtBlk |
| |
|
uint32_t | Pm1bEvtBlk |
| |
|
uint32_t | Pm1aCntBlk |
| |
|
uint32_t | Pm1bCntBlk |
| |
|
uint32_t | Pm2CntBlk |
| |
|
uint32_t | PmTmrBlk |
| |
|
uint32_t | Gpe0Blk |
| |
|
uint32_t | Gpe1Blk |
| |
|
uint8_t | Pm1EvtLen |
| |
|
uint8_t | Pm1CntLen |
| |
|
uint8_t | Pm2CntLen |
| |
|
uint8_t | PmTmrLen |
| |
|
uint8_t | Gpe0BlkLen |
| |
|
uint8_t | Gpe1BlkLen |
| |
|
uint8_t | Gpe1Base |
| |
|
uint8_t | CstCnt |
| |
|
uint16_t | PLvl2Lat |
| |
|
uint16_t | PLvl3Lat |
| |
|
uint16_t | FlushSize |
| |
|
uint16_t | FlushStride |
| |
|
uint8_t | DutyOffset |
| |
|
uint8_t | DutyWidth |
| |
|
uint8_t | DayAlrm |
| |
|
uint8_t | MonAlrm |
| |
|
uint8_t | Century |
| |
|
uint16_t | IapcBootArch |
| |
|
uint8_t | Reserved2 |
| |
|
uint32_t | Flags |
| |
|
uint32_t | ResetReg1 |
| |
|
uint32_t | ResetReg2 |
| |
|
uint32_t | ResetReg3 |
| |
|
uint8_t | ResetValue |
| |
|
uint8_t | Reserved3 |
| |
|
uint8_t | Reserved4 |
| |
|
uint8_t | Reserved5 |
| |
|
uint64_t | XFirmwareCtrl |
| |
|
uint64_t | XDsdt |
| |
|
uint32_t | XPm1aEvtBlk1 |
| |
|
uint32_t | XPm1aEvtBlk2 |
| |
|
uint32_t | XPm1aEvtBlk3 |
| |
|
uint32_t | XPm1bEvtBlk1 |
| |
|
uint32_t | XPm1bEvtBlk2 |
| |
|
uint32_t | XPm1bEvtBlk3 |
| |
|
uint32_t | XPm1aCntBlk1 |
| |
|
uint32_t | XPm1aCntBlk2 |
| |
|
uint32_t | XPm1aCntBlk3 |
| |
|
uint32_t | XPm1bCntBlk1 |
| |
|
uint32_t | XPm1bCntBlk2 |
| |
|
uint32_t | XPm1bCntBlk3 |
| |
|
uint32_t | XPm2CntBlk1 |
| |
|
uint32_t | XPm2CntBlk2 |
| |
|
uint32_t | XPm2CntBlk3 |
| |
|
uint32_t | XPmTmrBlk1 |
| |
|
uint32_t | XPmTmrBlk2 |
| |
|
uint32_t | XPmTmrBlk3 |
| |
|
uint32_t | XGpe0Blk1 |
| |
|
uint32_t | XGpe0Blk2 |
| |
|
uint32_t | XGpe0Blk3 |
| |
|
uint32_t | XGpe1Blk1 |
| |
|
uint32_t | XGpe1Blk2 |
| |
|
uint32_t | XGpe1Blk3 |
| |
|
uint32_t | SleepCtrlReg1 |
| |
|
uint32_t | SleepCtrlReg2 |
| |
|
uint32_t | SleepCtrlReg3 |
| |
|
uint32_t | SleepStatusReg1 |
| |
|
uint32_t | SleepStatusReg2 |
| |
|
uint32_t | SleepStatusReg3 |
| |
The documentation for this struct was generated from the following file:


croutine. More...
croutine.
h
crQUEUE_SEND_FROM_ISR( xQueueHandle pxQueue, void *pvItemToQueue, portBASE_TYPE xCoRoutinePreviouslyWoken )
The macro's crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() are the co-routine equivalent to the xQueueSendFromISR() and xQueueReceiveFromISR() functions used by tasks.
crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() can only be used to pass data between a co-routine and and ISR, whereas xQueueSendFromISR() and xQueueReceiveFromISR() can only be used to pass data between a task and and ISR.
crQUEUE_SEND_FROM_ISR can only be called from an ISR to send data to a queue that is being used from within a co-routine.
See the co-routine section of the WEB documentation for information on passing data between tasks and co-routines and between ISR's and co-routines.
| xQueue | The handle to the queue on which the item is to be posted. |
| pvItemToQueue | A pointer to the item that is to be placed on the queue. The size of the items the queue will hold was defined when the queue was created, so this many bytes will be copied from pvItemToQueue into the queue storage area. |
| xCoRoutinePreviouslyWoken | This is included so an ISR can post onto the same queue multiple times from a single interrupt. The first call should always pass in pdFALSE. Subsequent calls should pass in the value returned from the previous call. |
Example usage:
// A co-routine that blocks on a queue waiting for characters to be received. static void vReceivingCoRoutine( xCoRoutineHandle xHandle, unsigned portBASE_TYPE uxIndex ) { char cRxedChar; portBASE_TYPE xResult;// All co-routines must start with a call to crSTART(). crSTART( xHandle ); for( ;; ) { // Wait for data to become available on the queue. This assumes the // queue xCommsRxQueue has already been created! crQUEUE_RECEIVE( xHandle, xCommsRxQueue, &uxLEDToFlash, portMAX_DELAY, &xResult ); // Was a character received? if( xResult == pdPASS ) { // Process the character here. } } // All co-routines must end with a call to crEND(). crEND();}
// An ISR that uses a queue to send characters received on a serial port to // a co-routine. void vUART_ISR( void ) { char cRxedChar; portBASE_TYPE xCRWokenByPost = pdFALSE;// We loop around reading characters until there are none left in the UART. while( UART_RX_REG_NOT_EMPTY() ) { // Obtain the character from the UART. cRxedChar = UART_RX_REG; // Post the character onto a queue. xCRWokenByPost will be pdFALSE // the first time around the loop. If the post causes a co-routine // to be woken (unblocked) then xCRWokenByPost will be set to pdTRUE. // In this manner we can ensure that if more than one co-routine is // blocked on the queue only one is woken by this ISR no matter how // many characters are posted to the queue. xCRWokenByPost = crQUEUE_SEND_FROM_ISR( xCommsRxQueue, &cRxedChar, xCRWokenByPost ); }}


Reports empty
try
blocks, including try-with-resources statements. Try blocks with comments are still considered to be empty.
This inspection does not report in JSP files.


I am using Tin as the cover page. Without packaging, this Tin is boring, nothing special, no one is willing to buy it home. It’s a Tin only. What I want to present here is, I am nothing special only if you flashily take a look on me. Open it, ponder carefully, this Tin will give you another thought. After you open this Tin, you can discover I got a lot of different pieces. These pieces can create so many beautiful pictures in different combination. You can check my FULL VERSION. Hope you enjoy both!
In our life, most of the advertisement campaign media will be poster, TVC, activities. For most of the Hong Konger, they need to work at 8a.m to 7p.m, not included OT. The time that they travelling is part of the time can let them to do some relax. I don’t think they want to use their time to read the poster or TVC. I hope I can create the advertising that can cause their curious, and to look around. Like using aroma, 3D projection, or even though asking the model to walk a catwalk in the MTR tunnel in a reverse way.
Thought this campaign, we hope to promote GAP has design different clothes and shoes that are specifically with for every generation..
As Hong Kong still have quite a lot of people do not know JumpsPower or even do not know there is a mini-jump starter invented. So, though this project I hope I can let Jump- sPower replace the traditional jump start way and let more people know this now tecnology.
It is almost Mother’s Day while doing this assignment, so, I use Mother’s day as my video theme. In most of the days of a year, we ignore our mum very often. Only few days, like mother’s day, we will think of mum.  Will you regret that you never listen to her words?
To convey the message “Less is more”, and tell the audience that, LUSH is an environmental friendly brand


|
x= and number from zero to the width of the current graphics mode
y= and number from zero to the height of the current graphics mode |
| Used to put a pixel on the screen defined by its x, y location in the current drawing color defined by the Color command |
|
;Set the color to green
Color 0,255,0 ;Draw a dot at location 100,200 with the color green plot 100,200 |


Classes
The following classes are available globally.
-
Holder for a result that will be provided later.
Functions that promise to do work asynchronously can return an
Future<T>
. The recipient of such an object can then observe it to be notified when the operation completes.The provider of a
Future<T>
can create and return a placeholder object before the actual result is available. For example:func getNetworkData(args) -> Future<NetworkResponse> { let promise: Promise<NetworkResponse> = queue.newPromise() queue.async { . . . do some work . . . promise.succeed(response) . . . if it fails, instead . . . promise.fail(error) } return promise.futureResult }
Note that this function returns immediately; the promise object will be given a value later on. This behaviour is common to Future/Promise implementations in many programming languages. If you are unfamiliar with this kind of object, the following resources may be helpful:
If you receive a
Future<T>
from another function, you have a number of options: The most common operation is to usethen()
ormap()
to add a function that will be called with the eventual result. Both methods returns a newFuture<T>
immediately that will receive the return value from your function, but they behave differently. If you have a function that can return synchronously, themap
function will transform the resultT
to a the new result valueU
and return anFuture<U>
.let networkData = getNetworkData(args) // When network data is received, convert it. let processedResult: Future<Processed> = networkData.map { (n: NetworkResponse) -> Processed in ... parse network data .... return processedResult }
If however you need to do more asynchronous processing, you can call
then()
. The return value of the function passed tothen
must be a newFuture<U>
object: the return value ofthen()
is a newFuture<U>
that will contain the eventual result of both the original operation and the subsequent one.// When converted network data is available, begin the database operation. let databaseResult: Future<DBResult> = processedResult.then { (p: Processed) -> Future<DBResult> in return someDatabaseOperation(p) }
In essence, future chains created via
then()
provide a form of data-driven asynchronous programming that allows you to dynamically declare data dependencies for your various operations.Future
chains created viathen()
are sufficient for most purposes. All of the registered functions will eventually run in order. If one of those functions throws an error, that error will bypass the remaining functions. You can usethenIfError()
to handle and optionally recover from errors in the middle of a chain.At the end of an
Future
chain, you can usewhenSuccess()
orwhenFailure()
to add an observer callback that will be invoked with the result or error at that point. (Note: If you ever find yourself invokingpromise.succeed()
from inside awhenSuccess()
callback, you probably should usethen()
orcascade(promise:)
instead.)Future
objects are typically obtained by:- Using
Future<T>.async
or a similar wrapper function. - Using
.then()
on an existing future to create a new future for the next step in a series of operations. - Initializing an
Future
that already has a value or an error
Declaration
Swift
public final class Future<T>
- Using


Form uses several ways to run the validation. Each field is handled differently, with its own rule.
Errors are shown using 3 different styles.
The final part of the form is validated only if the related option is checked, due to the fact that its fields are held separately.


Hello, my
is:
I want Fruit!
I live in a House
I work on a Farm
I love Music
Fruit: Apple
House: Brick
Farm: Big
Music: Classical
My age is:


We sell methodologies!
- exploit B2B users
- incubate collaborative methodologies
- innovate collaborative ROI
- enhance dot-com applications
- repurpose 24/7 functionalities
- morph proactive functionalities
- harness robust eyeballs
- visualize dot-com ROI
- facilitate plug-and-play paradigms
- productize user-centric niches
- benchmark enterprise e-tailers


Landing Page
Special Projects
This story is part of a series of specially designed stories that represents some of the best journalism The Post has to offer. Check out the rest of the special projects here.
MEAGAN HALL
08.24.17
Ohio’s previous season may have ended in perhaps the toughest way possible: a 3-0 defeat in the national championship game against Central Oklahoma.
But the feeling of falling just short should fuel Ohio's young and talented core toward making another deep run this upcoming season.
With depth on their side, the Bobcats have every reason to believe they'll be right back in the championship game come next spring.
Blake Nissen | FILE
Sophomore Austin Heakins celebrates with his teammates after a goal scored against John Carroll in their September 24th, 2016 game.
Ohio lost 10 seniors from its previous squad, three of which finished top-five in scoring last season, but coach Sean Hogan and the rest of the team are viewing that statistic from a different angle.
Expand that number, and the Bobcats actually lost just three of their top-10 leading scorers, with four of the returning seven players entering their sophomore year and stepping into bigger roles on the team.
"I think guys like Gianni Evangelisti, who played a lot of last year on the third line, will see a lot more shifts and more games on our top line," Hogan said. "We're looking for Jacob Houston to be great on our back end as well."
In Evangelisti and Houston, who enter their sophomore years, Ohio already has two players capable of producing points from both forward and defense. Evangelisti finished third among forwards with 32 points and led the team with a plus-22 plus/minus rating, while Houston led the defense with 28 points in addition to finishing plus-11.
The Bobcats will also have sophomores Austin Heakins and Tyler Harkins, who finished last season with 27 and 24 points, respectively. Heakins also finished second on the team with 22 assists.
Ohio also has young talent in net, as sophomore Jimmy Thomas will likely see the majority of the Bobcats' games — a task he's already completed. In his freshman season, Thomas led all Ohio goalies with 19 games played and went 13-4-1 and tallied three shutouts with a 2.38 goals-against average.
Last year's crop of new players gave Ohio the boost it needed to reach its first national championship game appearance since 2004.
This season, the Bobcats are hoping the newcomers will provide the missing ingredient needed to finish that final game with a win.
"We had a great freshman class last year," Hogan said. "We're excited about this group that we're bringing in. The difference this year is that there are a lot more transfers."
Ohio has currently added seven players to its 2017-18 squad, with three coming as NCAA transfers. Defenseman Nick Grose comes from Utica College, forward Garrett Elmore transfers from Gustavus Adolphus and forward Timmy Thurnau comes from Elmira.
"We're bringing in some guys that have college experience under their belt, so that helps a bunch," Hogan said.
One aspect Hogan wanted this year's team to improve upon is net-front goals, which he believes will come with more "grit" and a heightened physical presence — a characteristic that several new players, like forward/defenseman Shawn Baird, forward Zach Frank and Elmore, have voiced as a key part of their games.
If the new recruits meet the expectations, Ohio could have even more of a complete team than that of last season.
- Ohio will unveil new home jerseys in August that will honor its upcoming 60th anniversary season. Additionally, the Bobcats will also have on-ice logos at Bird Arena to commemorate the milestone. Information about the 60th anniversary logo, which was unveiled in June, can be found here.
- The Bobcats enter 2017-18 looking to capture their 16th straight season with at least 25 wins.
BackLanding Page
This story is part of a series of specially designed stories that represents some of the best journalism The Post has to offer. Check out the rest of the special projects here.


Review: Wilde
Starring: Stephen Fry, Jude Law, Jennifer Ehle, Gemma Jones, Michael Sheen
Directed by Brian Gilbert
Approx. running time: 110 min
It seems a trend in modern works about Oscar Wilde to narrow him down to nothing but a man ruined by his homosexuality. "Wilde", which opened friday, can't be excluded from that group. Both San Francisco and Broadway in NY have a play called "Gross Indecency" about the trial surrounding Oscar Wilde's sexual affairs with younger men. SF also had a one man show last winter that focused largely on the torment he had to endure because of his sexuality. What "Wilde" and all these other plays forget is that behind this "scandal" was a brilliant, witty and successful writer in the late 19th century who contributed to world literature.
The first 30 minutes of "Wilde" does nothing but pound into the viewers heads that the character is indeed homosexual in spite of his wife and two children. Moderation was not used to introduce it. Each scene of social and family events seemed intercut with homosexual love scenes. After the first half hour, I found that the film up to that point lacked focus and drive. I wondered where it was going, and if it was going to live up to it's name. After all, a film simply named after a real person should cover that person's life, their personality and what was important about them, or at least how their work influenced culture. "Wilde" has the amazing ability to turn such a fascinating man into a nobody. Oscar Wilde did not need to be the focus of this film, and, should you decide that you want to see this to learn more about him, you will be disappointed. The story is one of a man who has a social status and how his sexual affairs with younger men, one in particular, ends up ruining him. The fact that he is Oscar Wilde, playwrite, poet and author, seems secondary. The successful opening nights of "Lady Windermere's Fan" and "The Importance of Being Earnest" as well as references to "The Picture of Dorian Gray" and "Solome" are tossed in to remind the viewer who they are watching.
Stephen Fry did a fine job of portraying the tormented writer, but his talent seemed wasted on a character who never lived up to what the real man really was. Jude Law played his younger lover, Lord Alfred Douglas, "Bosie" as he is known, quite well. His performance as a snotty, slutty pretty boy is another thing that makes the film watchable.
Perhaps a year of anticipation of a film about the life and times of Oscar Wilde in which the lead role would be played by one of my favorite British comics, had something to do with the letdown, but not much. The costumes are glorious, the sets decadent and the performances good, but "Wilde" does not hold together as anything other than a preachy film about how difficult it was to be homosexual 120 years ago. I am still waiting for a production about a man who was known for his wit and intelligence, a true artist, rather than the men he slept with.
** out of **** stars Copyright © 1998 Nick Amado Comments, questions, complaints? Email me at<EMAIL_ADDRESS>The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Want to see someone speak at a future event? Nominate them now. About you Your name * First Last Your Email * Your Twitter account * About the speaker Speaker's name * First Last Twitter account * Website, blog or portfolio * In a tweet, why would they be a great speaker? * Maximum Allowed: 140 characters. Currently Used: 0 characters. Do Not Fill This Out


24-25th April, 2023
Hosted at Sainsbury Laboratory, University of Cambridge
We’re pleased to announce that the 2023 event will be held on the 24th and 25th of April at the Sainsbury Laboratory in Cambridge. NoCaSS 2023 will allow students and post-docs to present their research, form collaborations, and learn from each other. We are also introducing scientist-oriented workshops on careers, publishing, and transferable skills to help the participants be active members in plant and microbial research across the world.
The conference will cover transport and accommodation for Norwich-based attendees, thanks to generous funding from our sponsors. We cannot wait to welcome you to this meeting in April.
Please submit an abstract (less than 300 words) and include your favourite photo to represent your research for the abstract book.
We would like to thank our sponsors for their generous contribution, without whom this event would not have been possible.


AI Sunsets is a cycle of high-level sessions about artificial intelligence. It aims to connect people and their ideas on this matter.
Connect to the audience or tell your truth
More than a family, a company.


This test reproduces the first part of issue https://github.com/csf-dev/ZPT-Sharp/issues/232
Here is that unfamiliar character in a macro: ✔
This document contains an unfamiliar character. Here is that unfamiliar character in a macro: ✔ Also, including the character via TAL shouldn't trigger an error either. ✔


Welcome, {{name}}!
Your NUCoins: {{coins}}
Transaction history
Your Recent Transactions:
- Title:{{transaction.Title}}
Amount:{{transaction.Amount}}
Date: {{transaction.Date }}
Time: {{transaction.Time}}
Description: {{transaction.Description}}
You have no transactions to be showed.


About Us
Our Mission
We are very committed to the artisan food community and to fostering the values of that community here at the Ferry Building. We envision the Ferry Building Marketplace as a vibrant gathering of local farmers, artisan producers, and independently owned and operated food businesses and the customers they serve. We are creating a community of like-minded people that will:
- Showcase small regional producers that practice traditional farming or production techniques and who develop personal relationships with their customers.
- Promote the Bay Area’s vast ethnic diversity and serve and an incubator for artisan producers who are returning to sustainable methods of agriculture and production.
- Provide a central location for the promotion of the world-class food and wine producing regions of Northern California and recognize wine's connection to our rich regional cuisine.
- Collaborate with local transit authorities to build strong regional ties to the Ferry Building and support the revitalization of the San Francisco waterfront.
- Operate as a community gathering-place for the celebration of local culture and cuisine.


Massachusetts man wins $1M lottery twice in 18 months
by Jared Leone, Cox Media Group National Content DeskMENDON, Mass. - Luck struck twice for a Massachusetts man who won a $1 million lottery prize for the second time in 18 months.
Rolf Rhodes won $1 million on a $4 million Instant Jackpot game ticket Wednesday, according to the Massachusetts State Lottery. Rhodes chose to receive 20 yearly payments of $50,000. The ticket cost $10.
On May 22, 2018, Rhodes won $1 million on the Hit $1,000 $10 instant game. He chose a one-time payout of $650,000, before taxes.


Yadukumari. S. R.
(D/o. Smt. S.N. Latha & Sri S.T. Ramesha)
WEDS
Ravikiran Janardhana
(S/o. Smt. V.K. Chudamani & Sri Janardhana. R)
on Wednesday, 17th February 2016
at
#12, Basavanagudi Road, Near Ramkrishna Ashrama
Bangalore - 560004.
Varapooja
Tue, Feb 16 2016
12:30 pm
Reception
Tue, Feb 16 2016
7 pm
Muhurtham
Wed, Feb 17 2016
4 am to 4:30 am
Lagnam: Dhanur
Reception
Wed, Feb 17 2016
11:30 am onwards
Lunch
Wed, Feb 17 2016
12:30 pm