Пример #1
0
def create_permission_enum(key, member_names):
    """Create a permission enum."""
    name = derive_name(key)
    permission_enum = Enum(name, list(member_names))
    permission_enum.__key__ = key
    permission_enum.__repr__ = lambda self: '<{}>'.format(self)
    return permission_enum
Пример #2
0
 def add_enum(self, *args, **kwargs):
     """
     Add an enumeration to the module. See the documentation for
     L{Enum.__init__} for information on accepted parameters.
     """
     if len(args) == 1 and len(kwargs) == 0 and isinstance(args[0], Enum):
         enum = args[0]
         warnings.warn("add_enum has changed API; see the API documentation",
                       DeprecationWarning, stacklevel=2)
     else:
         enum = Enum(*args, **kwargs)
     enum.stack_where_defined = traceback.extract_stack()
     self._add_enum_obj(enum)
     return enum
Пример #3
0
    def test_shouldReturnDefaultMaxWordsLearningFromSettingsWhenNoEntryExists(self):
        enum = Enum('enum', 'LEARN_RYTHM_MULTIPLIER LEARN_BASE_RYTHM LEARN_MAX_WORDS')
        for given_key, expected_value in {
            'LEARN_RYTHM_MULTIPLIER': '2',
            'LEARN_BASE_RYTHM': '2',
            'LEARN_MAX_WORDS': '5',
        }.items():
            # Given
            self.configuration_objects.filter.return_value = []

            # When
            result = self.conf.get_configuration(enum.__getattr__(given_key),
                                                 configuration_model=self.configuration_model)

            # Then
            self.assertEqual(result, expected_value)
Пример #4
0
def _PoCEntityTypes_parser(cls, value):
	if not isinstance(value, str):
		return Enum.__new__(cls, value)
	else:
		# map strings to enum values, default to Unknown
		return {
			'src':      EntityTypes.Source,
			'tb':        EntityTypes.Testbench,
			'nl':        EntityTypes.NetList
		}.get(value,	EntityTypes.Unknown)
def test_base_enum():
    e = Enum(operators=frozenset([PLUS, OR, NOT]))
    e.leafs = [0, 'x']
    result = []
    for t in e.base_enum(3):
        print t
        result.append(t)

    expected = sorted([
        ('not', ('not', 0)),
        ('not', ('not', 'x')),
        ('plus', 0, 0),
        ('plus', 0, 'x'),
        ('plus', 'x', 'x'),
        ('or', 0, 0),
        ('or', 0, 'x'),
        ('or', 'x', 'x'),
    ])

    eq_(sorted(result), expected)
def test_with_enum():
    e = Enum(operators=frozenset(
        [NOT, SHL1, SHR4, AND, PLUS, OR, XOR]))
    all_terms = list(e.base_enum(3))

    d = SemanticDict()
    for t in all_terms:
        if t not in d:
            d[t] = t
    print d.to_str()

    unique_terms = list(d.itervalues())

    for i, t1 in enumerate(unique_terms):
        for j in range(i):
            assert not terms_equivalent(t1, unique_terms[j])

    for t in all_terms:
        assert any(terms_equivalent(t, u) for u in unique_terms)

    print len(all_terms), 'terms total'
    print len(unique_terms), 'unique terms'
Пример #7
0
class EnumTests(unittest.TestCase):
    def setUp(self):
        self.enum = Enum('Dog','Cat','Fish')


    def testEmptyNotAllowed(self):
        try:
            enum = Enum()
        except AssertionError:
            pass
        else:
            fail("Expected assertion - empty enums not allowed")

    def testInclusion(self):
        assert self.enum.Cat

    def testInclusion_case(self):
        try:
            items = self.enum.cat
        except:
            pass
        else:
            fail("Expected assertion - enums are case sensitive")

    def testExclusion(self):
        try:
            items = self.enum.Frog
        except:
            pass
        else:
            fail("Expected assertion - item not in set")

    def testEquals(self):
        cat = self.enum.Cat
        anotherCat = self.enum.Cat

        assert (cat == anotherCat)

    def testLength(self):
        assert(self.enum.__len__() == 3)
Пример #8
0
    def __init__(self, code):
        Enum.__init__(self)

        # cached canonical code
        self._code = self._canonicalize_code(code)
Пример #9
0
from enum import Enum


ACTIONS = Enum('API functions', 'MATCHES PLAYERS TEAMS')
BASE_URL = 'https://api.dc01.gamelockerapp.com/shards/global'
SUCCESS_CODES = [200]
Пример #10
0
 def __lt__(self, other):
     return int(self).__lt__(other) if isinstance(other, int) else Enum.__lt__(self, other)
Пример #11
0
    opts.wrap_mode = None
    opts.prefix = prefix
    opts.cmd_line_options = {}
    return opts


def get_fake_env(sdir='', bdir=None, prefix='', opts=None):
    if opts is None:
        opts = get_fake_options(prefix)
    env = Environment(sdir, bdir, opts)
    env.coredata.compiler_options.host['c']['args'] = FakeCompilerOptions()
    env.machines.host.cpu_family = 'x86_64'  # Used on macOS inside find_library
    return env


Backend = Enum('Backend', 'ninja vs xcode')

if 'MESON_EXE' in os.environ:
    meson_exe = mesonlib.split_args(os.environ['MESON_EXE'])
else:
    meson_exe = None

if mesonlib.is_windows() or mesonlib.is_cygwin():
    exe_suffix = '.exe'
else:
    exe_suffix = ''


def get_meson_script():
    '''
    Guess the meson that corresponds to the `mesonbuild` that has been imported
Пример #12
0
 def test_iteration_order(self):
     Fruit = Enum('Fruit',[('Apple',2), ('Orange',0), ('Banana',1)])
     expected_list = [Fruit.Orange,Fruit.Banana,Fruit.Apple]
     self.assertEqual(expected_list,Fruit.items())
Пример #13
0
class Config:
    """Configuration options.

    All available options, their types, and their descriptions are defined in
    :file:`config_default.yaml`.
    """
    def __init__(self, folder: str = None, load_default=True):
        """Initialize with the default configuration"""
        if load_default:
            import kge
            from kge.misc import filename_in_module

            with open(filename_in_module(kge, "config-default.yaml"),
                      "r") as file:
                self.options: Dict[str,
                                   Any] = yaml.load(file,
                                                    Loader=yaml.SafeLoader)
        else:
            self.options = {}

        self.folder = folder  # main folder (config file, checkpoints, ...)
        self.log_folder = (
            None  # None means use self.folder; used for kge.log, trace.yaml
        )
        self.log_prefix: str = None

    # -- ACCESS METHODS ----------------------------------------------------------------

    def get(self, key: str, remove_plusplusplus=True) -> Any:
        """Obtain value of specified key.

        Nested dictionary values can be accessed via "." (e.g., "job.type"). Strips all
        '+++' keys unless `remove_plusplusplus` is set to `False`.

        """
        result = self.options
        for name in key.split("."):
            try:
                result = result[name]
            except KeyError:
                raise KeyError(f"Error accessing {name} for key {key}")

        if remove_plusplusplus and isinstance(result, collections.Mapping):

            def do_remove_plusplusplus(option):
                if isinstance(option, collections.Mapping):
                    option.pop("+++", None)
                    for values in option.values():
                        do_remove_plusplusplus(values)

            result = copy.deepcopy(result)
            do_remove_plusplusplus(result)

        return result

    def get_default(self, key: str) -> Any:
        """Returns the value of the key if present or default if not.

        The default value is looked up as follows. If the key has form ``parent.field``,
        see if there is a ``parent.type`` property. If so, try to look up ``field``
        under the key specified there (proceeds recursively). If not, go up until a
        `type` field is found, and then continue from there.

        """
        try:
            return self.get(key)
        except KeyError as e:
            last_dot_index = key.rfind(".")
            if last_dot_index < 0:
                raise e
            parent = key[:last_dot_index]
            field = key[last_dot_index + 1:]
            while True:
                # self.log("Looking up {}/{}".format(parent, field))
                try:
                    parent_type = self.get(parent + "." + "type")
                    # found a type -> go to this type and lookup there
                    new_key = parent_type + "." + field
                    last_dot_index = new_key.rfind(".")
                    parent = new_key[:last_dot_index]
                    field = new_key[last_dot_index + 1:]
                except KeyError:
                    # no type found -> go up hierarchy
                    last_dot_index = parent.rfind(".")
                    if last_dot_index < 0:
                        raise e
                    field = parent[last_dot_index + 1:] + "." + field
                    parent = parent[:last_dot_index]
                    continue
                try:
                    value = self.get(parent + "." + field)
                    # uncomment this to see where defaults are taken from
                    # self.log(
                    #     "Using value of {}={} for key {}".format(
                    #         parent + "." + field, value, key
                    #     )
                    # )
                    return value
                except KeyError:
                    # try further
                    continue

    def get_first_present_key(self, *keys: str, use_get_default=False) -> str:
        "Return the first key for which ``get`` or ``get_default`` finds a value."
        for key in keys:
            try:
                self.get_default(key) if use_get_default else self.get(key)
                return key
            except KeyError:
                pass
        raise KeyError("None of the following keys found: ".format(keys))

    def get_first(self, *keys: str, use_get_default=False) -> Any:
        "Return value (or default value) of the first valid key present or KeyError."
        if use_get_default:
            return self.get_default(
                self.get_first_present_key(*keys, use_get_default=True))
        else:
            return self.get(self.get_first_present_key(*keys))

    Overwrite = Enum("Overwrite", "Yes No Error")

    def set(self,
            key: str,
            value,
            create=False,
            overwrite=Overwrite.Yes,
            log=False) -> Any:
        """Set value of specified key.

        Nested dictionary values can be accessed via "." (e.g., "job.type").

        If ``create`` is ``False`` , raises :class:`ValueError` when the key
        does not exist already; otherwise, the new key-value pair is inserted
        into the configuration.

        """
        from kge.misc import is_number

        splits = key.split(".")
        data = self.options

        # flatten path and see if it is valid to be set
        path = []
        for i in range(len(splits) - 1):
            if splits[i] in data:
                create = create or "+++" in data[splits[i]]
            else:
                if create:
                    data[splits[i]] = dict()
                else:
                    raise KeyError(("{} cannot be set because creation of " +
                                    "{} is not permitted").format(
                                        key, ".".join(splits[:(i + 1)])))
            path.append(splits[i])
            data = data[splits[i]]

        # check correctness of value
        try:
            current_value = data.get(splits[-1])
        except:
            raise Exception(
                "These config entries {} {} caused an error.".format(
                    data, splits[-1]))

        if current_value is None:
            if not create:
                raise ValueError("key {} not present".format(key))

            if isinstance(value, str) and is_number(value, int):
                value = int(value)
            elif isinstance(value, str) and is_number(value, float):
                value = float(value)
        else:
            if (isinstance(value, str) and isinstance(current_value, float)
                    and is_number(value, float)):
                value = float(value)
            elif (isinstance(value, str) and isinstance(current_value, int)
                  and is_number(value, int)):
                value = int(value)
            if type(value) != type(current_value):
                raise ValueError(
                    "key {} has incorrect type (expected {}, found {})".format(
                        key, type(current_value), type(value)))
            if overwrite == Config.Overwrite.No:
                return current_value
            if overwrite == Config.Overwrite.Error and value != current_value:
                raise ValueError("key {} cannot be overwritten".format(key))

        # all fine, set value
        data[splits[-1]] = value
        if log:
            self.log("Set {}={}".format(key, value))
        return value

    def _import(self, module_name: str):
        """Imports the specified module configuration.

        Adds the configuration options from kge/model/<module_name>.yaml to
        the configuration. Retains existing module configurations, but verifies
        that fields and their types are correct.

        """
        import kge.model, kge.model.embedder
        from kge.misc import filename_in_module

        # load the module_name
        module_config = Config(load_default=False)
        module_config.load(
            filename_in_module([kge.model, kge.model.embedder],
                               "{}.yaml".format(module_name)),
            create=True,
        )
        if "import" in module_config.options:
            del module_config.options["import"]

        # add/verify current configuration
        for key in module_config.options.keys():
            cur_value = None
            try:
                cur_value = {key: self.get(key)}
            except KeyError:
                continue
            module_config.set_all(cur_value, create=False)

        # now update this configuration
        self.set_all(module_config.options, create=True)

        # remember the import
        imports = self.options.get("import")
        if imports is None:
            imports = module_name
        elif isinstance(imports, str):
            imports = [imports, module_name]
        else:
            imports.append(module_name)
            imports = list(dict.fromkeys(imports))
        self.options["import"] = imports

    def set_all(self,
                new_options: Dict[str, Any],
                create=False,
                overwrite=Overwrite.Yes):
        for key, value in Config.flatten(new_options).items():
            self.set(key, value, create, overwrite)

    def load(
        self,
        filename: str,
        create=False,
        overwrite=Overwrite.Yes,
        allow_deprecated=True,
    ):
        """Update configuration options from the specified YAML file.

        All options that do not occur in the specified file are retained.

        If ``create`` is ``False``, raises :class:`ValueError` when the file
        contains a non-existing options. When ``create`` is ``True``, allows
        to add options that are not present in this configuration.

        If the file has an import or model field, the corresponding
        configuration files are imported.

        """
        with open(filename, "r") as file:
            new_options = yaml.load(file, Loader=yaml.SafeLoader)
        self.load_options(
            new_options,
            create=create,
            overwrite=overwrite,
            allow_deprecated=allow_deprecated,
        )

    def load_options(self,
                     new_options,
                     create=False,
                     overwrite=Overwrite.Yes,
                     allow_deprecated=True):
        "Like `load`, but loads from an options object obtained from `yaml.load`."
        # import model configurations
        if "model" in new_options:
            model = new_options.get("model")
            # TODO not sure why this can be empty when resuming an ax
            # search with model as a search parameter
            if model:
                self._import(model)
        if "import" in new_options:
            imports = new_options.get("import")
            if not isinstance(imports, list):
                imports = [imports]
            for module_name in imports:
                self._import(module_name)
            del new_options["import"]

        # process deprecated options
        if allow_deprecated:
            new_options = _process_deprecated_options(
                Config.flatten(new_options))

        # now set all options
        self.set_all(new_options, create, overwrite)

    def save(self, filename):
        """Save this configuration to the given file"""
        with open(filename, "w+") as file:
            file.write(yaml.dump(self.options))

    @staticmethod
    def flatten(options: Dict[str, Any]) -> Dict[str, Any]:
        """Returns a dictionary of flattened configuration options."""
        result = {}
        Config.__flatten(options, result)
        return result

    @staticmethod
    def __flatten(options: Dict[str, Any], result: Dict[str, Any], prefix=""):
        for key, value in options.items():
            fullkey = key if prefix == "" else prefix + "." + key
            if type(value) is dict:
                Config.__flatten(value, result, prefix=fullkey)
            else:
                result[fullkey] = value

    def clone(self, subfolder: str = None) -> "Config":
        """Return a deep copy"""
        new_config = Config(folder=copy.deepcopy(self.folder),
                            load_default=False)
        new_config.options = copy.deepcopy(self.options)
        if subfolder is not None:
            new_config.folder = os.path.join(self.folder, subfolder)
        return new_config

    # -- LOGGING AND TRACING -----------------------------------------------------------

    def log(self, msg: str, echo=True, prefix=""):
        """Add a message to the default log file.

        Optionally also print on console. ``prefix`` is used to indent each
        output line.

        """
        with open(self.logfile(), "a") as file:
            for line in msg.splitlines():
                if prefix:
                    line = prefix + line
                if self.log_prefix:
                    line = self.log_prefix + line
                if echo:
                    print(line)
                file.write(str(datetime.datetime.now()) + " " + line + "\n")

    def trace(self,
              echo=False,
              echo_prefix="",
              echo_flow=False,
              log=False,
              **kwargs) -> Dict[str, Any]:
        """Write a set of key-value pairs to the trace file.

        The pairs are written as a single-line YAML record. Optionally, also
        echo to console and/or write to log file.

        And id and the current time is automatically added using key ``timestamp``.

        Returns the written k/v pairs.
        """
        kwargs["timestamp"] = time.time()
        kwargs["entry_id"] = str(uuid.uuid4())
        line = yaml.dump(kwargs, width=float("inf"),
                         default_flow_style=True).strip()
        if echo or log:
            msg = yaml.dump(kwargs, default_flow_style=echo_flow)
            if log:
                self.log(msg, echo, echo_prefix)
            else:
                for line in msg.splitlines():
                    if echo_prefix:
                        line = echo_prefix + line
                        print(line)
        with open(self.tracefile(), "a") as file:
            file.write(line + "\n")
        return kwargs

    # -- FOLDERS AND CHECKPOINTS ----------------------------------------------

    def init_folder(self):
        """Initialize the output folder.

        If the folder does not exists, create it, dump the configuration
        there and return ``True``. Else do nothing and return ``False``.

        """
        if not os.path.exists(self.folder):
            os.makedirs(self.folder)
            os.makedirs(os.path.join(self.folder, "config"))
            self.save(os.path.join(self.folder, "config.yaml"))
            return True
        return False

    def checkpoint_file(self, cpt_id: Union[str, int]) -> str:
        "Return path of checkpoint file for given checkpoint id"
        from kge.misc import is_number

        if is_number(cpt_id, int):
            return os.path.join(self.folder,
                                "checkpoint_{:05d}.pt".format(int(cpt_id)))
        else:
            return os.path.join(self.folder, "checkpoint_{}.pt".format(cpt_id))

    def last_checkpoint(self) -> Optional[int]:
        "Return epoch number of latest checkpoint"
        # stupid implementation, but works
        tried_epoch = 0
        found_epoch = 0
        while tried_epoch < found_epoch + 500:
            tried_epoch += 1
            if os.path.exists(self.checkpoint_file(tried_epoch)):
                found_epoch = tried_epoch
        if found_epoch > 0:
            return found_epoch
        else:
            return None

    @staticmethod
    def get_best_or_last_checkpoint(path: str) -> str:
        """Returns best (if present) or last checkpoint path for a given folder path."""
        config = Config(folder=path, load_default=False)
        checkpoint_file = config.checkpoint_file("best")
        if os.path.isfile(checkpoint_file):
            return checkpoint_file
        cpt_epoch = config.last_checkpoint()
        if cpt_epoch:
            return config.checkpoint_file(cpt_epoch)
        else:
            raise Exception("Could not find checkpoint in {}".format(path))

    # -- CONVENIENCE METHODS --------------------------------------------------

    def _check(self, key: str, value, allowed_values) -> Any:
        if value not in allowed_values:
            raise ValueError(
                "Illegal value {} for key {}; allowed values are {}".format(
                    value, key, allowed_values))
        return value

    def check(self, key: str, allowed_values) -> Any:
        """Raise an error if value of key is not in allowed.

        If fine, returns value.
        """
        return self._check(key, self.get(key), allowed_values)

    def check_default(self, key: str, allowed_values) -> Any:
        """Raise an error if value or default value of key is not in allowed.

        If fine, returns value.
        """
        return self._check(key, self.get_default(key), allowed_values)

    def check_range(self,
                    key: str,
                    min_value,
                    max_value,
                    min_inclusive=True,
                    max_inclusive=True) -> Any:
        value = self.get(key)
        if (value < min_value or (value == min_value and not min_inclusive)
                or value > max_value
                or (value == max_value and not max_inclusive)):
            raise ValueError(
                "Illegal value {} for key {}; must be in range {}{},{}{}".
                format(
                    value,
                    key,
                    "[" if min_inclusive else "(",
                    min_value,
                    max_value,
                    "]" if max_inclusive else ")",
                ))
        return value

    def logfile(self) -> str:
        folder = self.log_folder if self.log_folder else self.folder
        return os.path.join(folder, "kge.log")

    def tracefile(self) -> str:
        folder = self.log_folder if self.log_folder else self.folder
        return os.path.join(folder, "trace.yaml")
Пример #14
0
 def setUp(self):
     self.enum = Enum('Dog','Cat','Fish')
Пример #15
0
from enum import Enum
import re
from typing import Dict, List, Optional, TextIO
from linesep import read_paragraphs
from pydantic import BaseModel

ParserState = Enum("ParserState", "BADGES POST_LINKS POST_CONTENTS INTRO SECTIONS")

HEADER_LINK_RGX = r"`(?P<label>[^`<>]+) <(?P<url>[^>]+)>`_"

IMAGE_START = ".. image:: "


class Image(BaseModel):
    href: str
    target: Optional[str]
    alt: Optional[str]

    @classmethod
    def parse(cls, s: str) -> "Image":
        if not s.startswith(IMAGE_START):
            raise ValueError(f"Not an RST image: {s!r}")
        lines = s.splitlines(keepends=True)
        href = lines[0][len(IMAGE_START) :].strip()
        options: Dict[str, Optional[str]] = {
            "target": None,
            "alt": None,
        }
        opt_name: Optional[str] = None
        opt_value: Optional[str] = None
        for ln in lines[1:]:
Пример #16
0
def parse_header_type(cfg):
    header_type = Enum('HeaderType', ' '.join(cfg.HeaderType), module=__name__)
    return header_type
Пример #17
0
            Contours as a list of numpy.ndarray.
        """
        output = []
        for contour in input_contours:
            x, y, w, h = cv2.boundingRect(contour)
            if (w < min_width or w > max_width):
                continue
            if (h < min_height or h > max_height):
                continue
            area = cv2.contourArea(contour)
            if (area < min_area):
                continue
            if (cv2.arcLength(contour, True) < min_perimeter):
                continue
            hull = cv2.convexHull(contour)
            solid = 100 * area / cv2.contourArea(hull)
            if (solid < solidity[0] or solid > solidity[1]):
                continue
            if (len(contour) < min_vertex_count
                    or len(contour) > max_vertex_count):
                continue
            ratio = (float)(w) / h
            if (ratio < min_ratio or ratio > max_ratio):
                continue
            output.append(contour)
        return output


BlurType = Enum('BlurType',
                'Box_Blur Gaussian_Blur Median_Filter Bilateral_Filter')
Пример #18
0
class RemapLabels(Transform, CliPlugin):
    DefaultAction = Enum('DefaultAction', ['keep', 'delete'])

    @staticmethod
    def _split_arg(s):
        parts = s.split(':')
        if len(parts) != 2:
            import argparse
            raise argparse.ArgumentTypeError()
        return (parts[0], parts[1])

    @classmethod
    def build_cmdline_parser(cls, **kwargs):
        parser = super().build_cmdline_parser(**kwargs)
        parser.add_argument('-l', '--label', action='append',
            type=cls._split_arg, dest='mapping',
            help="Label in the form of: '<src>:<dst>' (repeatable)")
        parser.add_argument('--default',
            choices=[a.name for a in cls.DefaultAction],
            default=cls.DefaultAction.keep.name,
            help="Action for unspecified labels")
        return parser

    def __init__(self, extractor, mapping, default=None):
        super().__init__(extractor)

        assert isinstance(default, (str, self.DefaultAction))
        if isinstance(default, str):
            default = self.DefaultAction[default]

        assert isinstance(mapping, (dict, list))
        if isinstance(mapping, list):
            mapping = dict(mapping)

        self._categories = {}

        src_label_cat = self._extractor.categories().get(AnnotationType.label)
        if src_label_cat is not None:
            self._make_label_id_map(src_label_cat, mapping, default)

        src_mask_cat = self._extractor.categories().get(AnnotationType.mask)
        if src_mask_cat is not None:
            assert src_label_cat is not None
            dst_mask_cat = MaskCategories(attributes=src_mask_cat.attributes)
            dst_mask_cat.colormap = {
                id: src_mask_cat.colormap[id]
                for id, _ in enumerate(src_label_cat.items)
                if self._map_id(id) or id == 0
            }
            self._categories[AnnotationType.mask] = dst_mask_cat

        src_points_cat = self._extractor.categories().get(AnnotationType.points)
        if src_points_cat is not None:
            assert src_label_cat is not None
            dst_points_cat = PointsCategories(attributes=src_points_cat.attributes)
            dst_points_cat.items = {
                id: src_points_cat.items[id]
                for id, item in enumerate(src_label_cat.items)
                if self._map_id(id) or id == 0
            }
            self._categories[AnnotationType.points] = dst_points_cat

    def _make_label_id_map(self, src_label_cat, label_mapping, default_action):
        dst_label_cat = LabelCategories(attributes=src_label_cat.attributes)
        id_mapping = {}
        for src_index, src_label in enumerate(src_label_cat.items):
            dst_label = label_mapping.get(src_label.name)
            if not dst_label and default_action == self.DefaultAction.keep:
                dst_label = src_label.name # keep unspecified as is
            if not dst_label:
                continue

            dst_index = dst_label_cat.find(dst_label)[0]
            if dst_index is None:
                dst_index = dst_label_cat.add(dst_label,
                    src_label.parent, src_label.attributes)
            id_mapping[src_index] = dst_index

        if log.getLogger().isEnabledFor(log.DEBUG):
            log.debug("Label mapping:")
            for src_id, src_label in enumerate(src_label_cat.items):
                if id_mapping.get(src_id):
                    log.debug("#%s '%s' -> #%s '%s'",
                        src_id, src_label.name, id_mapping[src_id],
                        dst_label_cat.items[id_mapping[src_id]].name
                    )
                else:
                    log.debug("#%s '%s' -> <deleted>", src_id, src_label.name)

        self._map_id = lambda src_id: id_mapping.get(src_id, None)
        self._categories[AnnotationType.label] = dst_label_cat

    def categories(self):
        return self._categories

    def transform_item(self, item):
        # TODO: provide non-inplace version
        annotations = []
        for ann in item.annotations:
            if ann.type in { AnnotationType.label, AnnotationType.mask,
                AnnotationType.points, AnnotationType.polygon,
                AnnotationType.polyline, AnnotationType.bbox
            } and ann.label is not None:
                conv_label = self._map_id(ann.label)
                if conv_label is not None:
                    ann._label = conv_label
                    annotations.append(ann)
            else:
                annotations.append(ann)
        item._annotations = annotations
        return item
Пример #19
0
from enum import Enum
from collections import namedtuple

Type = Enum("Type", ("CURE", "HEALTHY", "SICK", "DYING", "DEAD"))
Agent = namedtuple("Agent", ("name", "category"))


def meetup(agent_listing: tuple) -> list:
    """Model the outcome of the meetings of pairs of agents.

    The pairs of agents are ((a[0], a[1]), (a[2], a[3]), ...). If there's an uneven
    number of agents, the last agent will remain the same.

    Notes
    -----
    The rules governing the meetings were described in the question. The outgoing
    listing may change its internal ordering relative to the incoming one.

    Parameters
    ----------
    agent_listing : tuple of Agent
        A listing (tuple in this case) in which each element is of the Agent
        type, containing a 'name' field and a 'category' field, with 'category' being
        of the type Type.

    Returns
    -------
    updated_listing : list
        A list of Agents with their 'category' field changed according to the result
        of the meeting.
    """
Пример #20
0
import sys
from enum import Enum
from error import print_error_msg, ERRNUM
from loader import DictionaryLoader

# ex: python -m "name"
# ex: python -m "name" "ox"
ARGS = Enum("PY", "WORD", "TYPE", "MAX", AVAILABLE=2)


def parse_arguements(args):
    if len(args) < ARGS.AVAILABLE:
        print_error_msg(ERRNUM.E_ARGS)

    word = args[ARGS.WORD]
    try:
        module = args[ARGS.TYPE]
    except IndexError:
        module = 'ox'  # default module
    return (word, module)


if __name__ == "__main__":
    word, module = parse_arguements(sys.argv)
    dict_ins = DictionaryLoader.get_module(module)
    dict_ins.find_word(word).show_word()
Пример #21
0
                              name='followup_priorities',
                              validate_strings=True)

sqla_enum_types = [
    allowed_bandpasses,
    thumbnail_types,
    instrument_types,
    followup_priorities,
]

api_classnames = sa.Enum(
    *[
        k for k, v in facility_apis.__dict__.items()
        if inspect.isclass(v) and issubclass(v, facility_apis.FollowUpAPI)
        and v is not facility_apis.FollowUpAPI
    ],
    name='followup_apis',
    validate_strings=True,
)

listener_classnames = sa.Enum(
    *LISTENER_CLASSNAMES,
    name='followup_listeners',
    validate_strings=True,
)

py_allowed_magsystems = Enum('magsystems', ALLOWED_MAGSYSTEMS)
py_allowed_bandpasses = Enum('bandpasses', ALLOWED_BANDPASSES)
py_thumbnail_types = Enum('thumbnail_types', THUMBNAIL_TYPES)
py_followup_priorities = Enum('priority', FOLLOWUP_PRIORITIES)
Пример #22
0

possible_tokens = ['ARRAY', 'BOOLEAN', 'BREAK', 'CHAR', 'CONTINUE', 'DO', 'ELSE', 'FALSE', 'FUNCTION', 'IF', 'INTEGER', 'OF', 'STRING',
           'STRUCT', 'TRUE', 'TYPE', 'VAR', 'WHILE',
           'COLON', 'SEMI_COLON', 'COMMA', 'EQUALS', 'LEFT_SQUARE', 'RIGHT_SQUARE', 'LEFT_BRACES', 'RIGHT_BRACES',
           'LEFT_PARENTHESIS', 'RIGHT_PARENTHESIS', 'AND', 'OR', 'LESS_THAN', 'GREATER_THAN', 'LESS_OR_EQUAL',
           'GREATER_OR_EQUAL', 'NOT_EQUAL', 'EQUAL_EQUAL', 'PLUS', 'PLUS_PLUS', 'MINUS', 'MINUS_MINUS', 'TIMES', 'DIVIDE',
           'DOT', 'NOT', 'CHARACTER', 'NUMERAL', 'STRINGVAL', 'ID',
           'UNKNOWN']

possible_tokens_ids = ['array', 'boolean', 'break', 'char', 'continue', 'do', 'else', 'false', 'function', 'if', 'integer', 'of', 'string',
             'struct', 'true', 'type', 'var', 'while', ':', ';', ',', '=', '[', ']', '"', '"', '(', ')', '&&', '||', '<', '>', '<=',
             '>=', '!=', '==', '+', '++', '-', '--', '*', '/', '.', '!', 'character', 'numeral', 'stringval', 'id']


Tokens = Enum._create_('Tokens', possible_tokens, None, int)

def searchKeyWord(text):
    if possible_tokens_ids.__contains__(text.lower()):
        return possible_tokens_ids.index(text.lower())+1
    else:
        return Tokens.ID.value

def searchName(text):
    if possible_tokens.__contains__(text.upper()):
        return possible_tokens.index(text.upper())
    else:
        return -1


Пример #23
0
from __future__ import unicode_literals
from collections import defaultdict
from enum import Enum
from tgen.logf import log_debug
from tgen.logf import log_warn
from tgen.tree import TreeData, TreeNode
import numpy as np

try:
    from pytreex.core.node import T
except ImportError:
    log_warn('Pytreex modules not available, will not be able to evaluate trees.')


EvalTypes = Enum(b'EvalTypes', b'TOKEN NODE DEP')
EvalTypes.__doc__ = """Evaluation flavors (tokens, tree node-only, tree dependency)"""


def collect_counts(sent, eval_type=EvalTypes.NODE):
    """Collects counts of different node/dependency types in the given t-tree.

    @param sent: the tree/sentence to collect counts from
    @param eval_type: if set to EvalTypes.NODE (default), count nodes (formemes, lemmas, dependency \
        direction), if set to EvalTypes.DEP, count dependencies (including parent's formeme, lemma, \
        dependency direction), if set to EvalTypes.TOKEN, count just word forms (in list of tokens).
    @rtype: defaultdict
    """
    counts = defaultdict(int)
    nodes = sent if isinstance(sent, list) else sent.get_descendants()
    for node in nodes:
class GeneticAlgorithm(Generic[C]):
    SelectionType = Enum("SelectionType", "ROULETTE TOURNAMENT")

    def __init__(
            self,
            initial_population: List[C],
            threshold: float,
            max_generations: int = 100,
            mutation_chance: float = 0.01,
            crossover_chance: float = 0.7,
            selection_type: SelectionType = SelectionType.TOURNAMENT) -> None:
        self._population: List[C] = initial_population
        self._threshold: float = threshold
        self._max_generations: int = max_generations
        self._mutation_chance: float = mutation_chance
        self._crossover_chance: float = crossover_chance
        self._selection_type: GeneticAlgorithm.SelectionType = selection_type
        self._fitness_key: Callable = type(self._population[0]).fitness

    # Use the probability distribution wheel to pick 2 parents
    # Note: will not work with negative fitness results
    def _pick_roulette(self, wheel: List[float]) -> Tuple[C, C]:
        return tuple(choices(self._population, weights=wheel, k=2))

    # Choose num_participants at random and take the best 2
    def _pick_tournament(self, num_participants: int) -> Tuple[C, C]:
        participants: List[C] = choices(self._population, k=num_participants)
        return tuple(nlargest(2, participants, key=self._fitness_key))

    # Replace the population with a new generation of individuals
    def _reproduce_and_replace(self) -> None:
        new_population: List[C] = []
        # keep going until we've filled the new generation
        while len(new_population) < len(self._population):
            # pick the 2 parents
            if self._selection_type == GeneticAlgorithm.SelectionType.ROULETTE:
                parents: Tuple[C, C] = self._pick_roulette(
                    [x.fitness() for x in self._population])
            else:
                parents = self._pick_tournament(len(self._population) // 2)
            # potentially crossover the 2 parents
            if random() < self._crossover_chance:
                new_population.extend(parents[0].crossover(parents[1]))
            else:
                new_population.extend(parents)
        # if we had an odd number, we'll have 1 extra, so we remove it
        if len(new_population) > len(self._population):
            new_population.pop()
        self._population = new_population  # replace reference

    # With _mutation_chance probability mutate each individual
    def _mutate(self) -> None:
        for individual in self._population:
            if random() < self._mutation_chance:
                individual.mutate()

    # Run the genetic algorithm for max_generations iterations
    # and return the best individual found
    def run(self) -> C:
        best: C = max(self._population, key=self._fitness_key)
        for generation in range(self._max_generations):
            if best.fitness(
            ) >= self._threshold:  # early exit if we beat threshold
                return best
            print(
                f"Generation {generation} Best {best.fitness()} Avg {mean(map(self._fitness_key, self._population))}"
            )
            self._reproduce_and_replace()
            self._mutate()
            highest: C = max(self._population, key=self._fitness_key)
            if highest.fitness() > best.fitness():
                best = highest  # found a new best
        return best  # best we found in max_generations
Пример #25
0
from enum import Enum

import mutablerecords

from openhtf.util import logs

_LOG = logging.getLogger(__name__)


class InvalidMeasurementDimensions(Exception):
    """Raised when a measurement is taken with the wrong number of dimensions."""


OutcomeDetails = collections.namedtuple('OutcomeDetails', 'code description')
Outcome = Enum('Outcome', ['PASS', 'FAIL', 'ERROR', 'TIMEOUT', 'ABORTED'])  # pylint: disable=invalid-name
# LogRecord is in openhtf.util.logs.LogRecord.


class Attachment(collections.namedtuple('Attachment', 'data mimetype')):
    """Encapsulate attachment data and guessed MIME type."""
    @property
    def sha1(self):
        return hashlib.sha1(self.data).hexdigest()


class TestRecord(  # pylint: disable=no-init
        mutablerecords.Record(
            'TestRecord', ['dut_id', 'station_id'], {
                'start_time_millis': int,
                'end_time_millis': None,
Пример #26
0

class Uint128Struct(c.Structure):
    _fields_ = [("hi", c.c_uint64), ("lo", c.c_uint64)]


ObjT = Enum(
    'ObjT',
    [
        # These are the only conf object types we care about.
        ('PROCESS', 0x7200000000000001),
        ('SERVICE', 0x7300000000000001),
        ('SDEV', 0x6400000000000001),
        ('DRIVE', 0x6b00000000000001),
        ('PROFILE', 0x7000000000000001),
        ('OBJV', 0x6a00000000000001),
        ('NODE', 0x6e00000000000001),
        ('SITE', 0x5300000000000001),
        ('RACK', 0x6100000000000001),
        ('ENCLOSURE', 0x6500000000000001),
        ('CONTROLLER', 0x6300000000000001),
        ('ROOT', 0x7400000000000001),
        ('POOL', 0x6f00000000000001),
        ('PVER', 0x7600000000000001)
    ])
ObjT.__doc__ = 'Motr conf object types and their m0_fid.f_container values'


class HaNoteStruct(c.Structure):
    # Constants for no_state field values as they are described in ha/note.h
Пример #27
0
class TestEnum(BackendInfraTest):
    def setUp(self):
        super(TestEnum,self).setUp()
        self.Colors = Enum('Colors',['Red','Green','Blue'])

    def test_get_by_name(self):
        red = self.Colors.Red
        self.assertEqual(red.name,'Red')
        self.assertEqual(red.val,0)
        self.assertEqual(str(red),'Red')

    def test_get_by_value(self):
        red = self.Colors.get_by_value(1)
        self.assertEqual(red.name,'Green')
        self.assertEqual(self.Colors.Blue, self.Colors.get_by_value(2))

    def test_specific_values(self):
        Priority = Enum('Priority',[('Critical',500), ('Medium',250), ('Low',0)])
        med = Priority.Medium
        self.assertEqual(med.val,250)

    def test_lookup_error(self):
        self.assertRaises(AttributeError,getattr, self.Colors,'Purple')
        self.assertRaises(KeyError,self.Colors.get_by_value, 5)

    def test_ctor(self):
        Enum('SomeEnum',[]) # check empty list (should work although not very useful)
        self.assertRaises(EnumException, Enum, 'SomeEnum', ['Yes',5,4])
        self.assertRaises(EnumException, Enum, 'SomeEnum', ['Yes',('No',4),('Maybe','MaybeNot')])
        self.assertRaises(EnumException, Enum, 'SomeEnum', ['Yes','No','Yes']) # duplicate name
        self.assertRaises(EnumException, Enum, 'SomeEnum', ['Yes','No',('Maybe',0)]) # duplicate value

    def test_cmp(self):
        self.assertEqual(self.Colors.Blue,self.Colors.Blue)
        self.assertNotEqual(self.Colors.Blue,self.Colors.Red)
        self.assert_(self.Colors.Red < self.Colors.Blue)

        # comparisons to other types or other enums
        self.assertNotEqual(self.Colors.Red,None)
        Genders = Enum('Genders', ['Male','Female'])
        Genders2 = Enum('Genders2', ['Male','Female','Undecided'])
        self.assertNotEqual(self.Colors.Red,Genders.Male)
        self.assertNotEqual(Genders.Male,Genders2.Male)

    def test_is_legal_value(self):
        self.assertEqual(self.Colors.is_legal_value(self.Colors.Red), True)
        self.assertEqual(self.Colors.is_legal_value(None), False)
        self.assertEqual(self.Colors.is_legal_value(True), False)

    def test_iteration_order(self):
        Fruit = Enum('Fruit',[('Apple',2), ('Orange',0), ('Banana',1)])
        expected_list = [Fruit.Orange,Fruit.Banana,Fruit.Apple]
        self.assertEqual(expected_list,Fruit.items())
        
    def test_add_item(self):
        white = self.Colors.add_item('White')
        self.assertEqual(white, self.Colors.White)
        self.assertEqual(self.Colors.White.val,3)
        self.Colors.add_item('Black',100)
        self.assertEqual(self.Colors.Black.val,100)
        self.assertRaises(EnumException, self.Colors.add_item, 'Red') # duplicate name
        self.assertRaises(EnumException, self.Colors.add_item, 'Purple', 2) # duplicate value
Пример #28
0
class QueryHistory(models.Model):
  """
  Holds metadata about all queries that have been executed.
  """
  STATE = Enum('submitted', 'running', 'available', 'failed', 'expired')
  SERVER_TYPE = ((BEESWAX, 'Beeswax'), (HIVE_SERVER2, 'Hive Server 2'))

  owner = models.ForeignKey(User, db_index=True)
  query = models.TextField()

  last_state = models.IntegerField(db_index=True)
  has_results = models.BooleanField(default=False)          # If true, this query will eventually return tabular results.
  submission_date = models.DateTimeField(auto_now_add=True)
  # In case of multi statements in a query, these are the id of the currently running statement
  server_id = models.CharField(max_length=1024, null=True)  # Aka secret, only query in the "submitted" state is allowed to have no server_id
  server_guid = models.CharField(max_length=1024, null=True, default=None)
  statement_number = models.SmallIntegerField(default=0)    # The index of the currently running statement
  operation_type = models.SmallIntegerField(null=True)
  modified_row_count = models.FloatField(null=True)
  log_context = models.CharField(max_length=1024, null=True)

  server_host = models.CharField(max_length=128, help_text=_('Host of the query server.'), default='')
  server_port = models.SmallIntegerField(help_text=_('Port of the query server.'), default=0)
  server_name = models.CharField(max_length=128, help_text=_('Name of the query server.'), default='')
  server_type = models.CharField(max_length=128, help_text=_('Type of the query server.'), default=BEESWAX, choices=SERVER_TYPE)
  query_type = models.SmallIntegerField(help_text=_('Type of the query.'), default=HQL, choices=((HQL, 'HQL'), (IMPALA, 'IMPALA')))

  design = models.ForeignKey('SavedQuery', to_field='id', null=True) # Some queries (like read/create table) don't have a design
  notify = models.BooleanField(default=False)                        # Notify on completion

  class Meta:
    ordering = ['-submission_date']

  @staticmethod
  def build(*args, **kwargs):
    if kwargs['server_type'] == HIVE_SERVER2:
      return HiveServerQueryHistory(*args, **kwargs)
    else:
      return BeeswaxQueryHistory(*args, **kwargs)

  def get_full_object(self):
    if self.server_type == HiveServerQueryHistory.node_type:
      return HiveServerQueryHistory.objects.get(id=self.id)
    else:
      return BeeswaxQueryHistory.objects.get(id=self.id)

  @staticmethod
  def get(id):
    if QueryHistory.objects.filter(id=id, server_type=BEESWAX).exists():
      return BeeswaxQueryHistory.objects.get(id=id)
    else:
      return HiveServerQueryHistory.objects.get(id=id)

  def get_type_name(self):
    if self.query_type == 1:
      return 'impala'
    else:
      return 'beeswax'

  def get_query_server_config(self):
    from beeswax.server.dbms import get_query_server_config

    query_server = get_query_server_config(self.get_type_name())
    query_server.update({
        'server_name': self.server_name,
        'server_host': self.server_host,
        'server_port': self.server_port,
        'server_type': self.server_type,
    })

    return query_server


  def get_current_statement(self):
    if self.design is not None:
      design = self.design.get_design()
      return design.get_query_statement(self.statement_number)
    else:
      return self.query

  def is_finished(self):
    is_statement_finished = not self.is_running()

    if self.design is not None:
      design = self.design.get_design()
      return is_statement_finished and self.statement_number + 1 == design.statement_count # Last statement
    else:
      return is_statement_finished

  def is_running(self):
    return self.last_state in (QueryHistory.STATE.running.index, QueryHistory.STATE.submitted.index)

  def is_success(self):
    return self.last_state in (QueryHistory.STATE.available.index,)

  def is_failure(self):
    return self.last_state in (QueryHistory.STATE.expired.index, QueryHistory.STATE.failed.index)

  def set_to_running(self):
    self.last_state = QueryHistory.STATE.running.index

  def set_to_failed(self):
    self.last_state = QueryHistory.STATE.failed.index

  def set_to_available(self):
    self.last_state = QueryHistory.STATE.available.index
Пример #29
0
Any issues can be reported to https://github.com/CalabreseLab

---
"""

import numpy as np

from enum import Enum
from collections import defaultdict
from itertools import product
from pandas import DataFrame

from seekr.my_tqdm import my_tqdm
from seekr.fasta_reader import Reader

Log2 = Enum('Log2', ('pre', 'post', 'none'))


class BasicCounter:
    """Generates overlapping kmer counts for a fasta file

    Parameters
    ----------
    infasta: str (default=None)
        Full path to fasta file to be counted
    outfile: str (default=None)
        Full path to the counts file to be saved
    k: int (default=6)
        Size of kmer to be counted
    binary: bool (default=True)
        Saves as numpy array if True, else saves as csv
Пример #30
0
class TestState(util.SubscribableStateMixin):
    """This class handles tracking the state of a running Test.

  This class encapsulates all the interesting transient bits of a running Test,
  as opposed to the openhtf.TestDescriptor class, which encapsulates static
  data associated with a Test (that is, it remains the same across invocations
  of Test.Execute()).

  Init Args:
    test_desc: openhtf.TestDescriptor instance describing the test to run,
        used to initialize some values here, but it is not modified.

  Attributes:
    test_record: TestRecord instance for the currently running test.
    logger: Logger that logs to test_record's log_records attribute.
    running_phase_state: PhaseState object for the currently running phase,
        if any, otherwise None.
    user_defined_state: Dictionary for users to persist state across phase
        invokations.  It's passed to the user via test_api.
    test_api: An openhtf.TestApi instance for passing to test phases,
        providing test authors access to necessary state information, while
        protecting internal-only structures from being accidentally modified.
        Note that if there is no running phase, test_api is also None.
    execution_uid: A UUID that is specific to this execution.
  """
    Status = Enum('Status', ['WAITING_FOR_TEST_START', 'RUNNING', 'COMPLETED'])

    def __init__(self, test_desc, execution_uid):
        super(TestState, self).__init__()
        self._status = self.Status.WAITING_FOR_TEST_START

        self.test_record = test_record.TestRecord(
            dut_id=None,
            station_id=conf.station_id,
            code_info=test_desc.code_info,
            # Copy metadata so we don't modify test_desc.
            metadata=copy.deepcopy(test_desc.metadata))
        self.logger = logs.initialize_record_logger(execution_uid,
                                                    self.test_record,
                                                    self.notify_update)
        self.plug_manager = plugs.PlugManager(test_desc.plug_types,
                                              self.logger)
        self.running_phase_state = None
        self.user_defined_state = {}
        self.execution_uid = execution_uid

    @property
    def test_api(self):
        """Create a TestApi for access to this TestState.

    The returned TestApi should be passed as the first argument to test
    phases.  Note that the return value is none if there is no
    self.running_phase_state set.  As such, this attribute should only
    be accessed within a RunningPhaseContext().
    """
        running_phase_state = self.running_phase_state
        return (running_phase_state and openhtf.TestApi(
            self.logger, self.user_defined_state, self.test_record,
            measurements.Collection(running_phase_state.measurements),
            running_phase_state.attachments, running_phase_state.attach,
            running_phase_state.attach_from_file, self.notify_update))

    @contextlib.contextmanager
    def running_phase_context(self, phase_desc):
        """Create a context within which a single phase is running.

    Yields a PhaseState object for tracking transient state during the
    execution of the phase, including the output PhaseRecord.  That PhaseState
    provides the TestApi to be passed into the test phase.

    Within this context, the Station API will report the given phase as the
    currently running phase.
    """
        assert not self.running_phase_state, 'Phase already running!'
        self.running_phase_state = PhaseState.from_descriptor(
            phase_desc, self.notify_update)
        try:
            with self.running_phase_state.record_timing_context:
                self.notify_update()  # New phase started.
                yield self.running_phase_state
        finally:
            # Clear notification callbacks so we can serialize measurements.
            for meas in self.running_phase_state.measurements.values():
                meas.set_notification_callback(None)
            self.test_record.phases.append(
                self.running_phase_state.phase_record)
            self.running_phase_state = None
            self.notify_update()  # Phase finished.

    def _asdict(self):
        """Return a dict representation of the test's state."""
        return {
            'status': self._status,
            'test_record': self.test_record,
            'plugs': self.plug_manager._asdict(),
            'running_phase_state': self.running_phase_state,
        }

    @property
    def is_finalized(self):
        return self._status == self.Status.COMPLETED

    @property
    def last_run_phase_name(self):
        """Get the name of the currently running phase, or None.

    Note that this name is not guaranteed to still be accurate by the time this
    method returns, so this should only be used for log messages/user display
    and not for programmatic purposes.
    """
        return self.running_phase_state and self.running_phase_state.name

    def set_status_from_phase_outcome(self, phase_outcome):
        """Set our internal state based on the given phase outcome.

    Args:
      phase_outcome: An instance of phase_executor.PhaseOutcome

    Returns: True if the test has finished prematurely (failed).
    """
        assert not self.is_finalized, 'Test already completed!'
        # Handle a few cases where the test is ending prematurely.
        if phase_outcome.raised_exception:
            self.logger.debug('Finishing test execution early due to phase '
                              'exception, outcome ERROR.')
            result = phase_outcome.phase_result
            if isinstance(result, phase_executor.ExceptionInfo):
                code = result.exc_type.__name__
                description = str(result.exc_val).decode('utf8', 'replace')
            else:
                # threads.ThreadTerminationError gets str'd directly.
                code = str(type(phase_outcome.phase_result).__name__)
                description = str(phase_outcome.phase_result).decode(
                    'utf8', 'replace')
            self.test_record.add_outcome_details(code, description)
            self.finalize(test_record.Outcome.ERROR)
        elif phase_outcome.is_timeout:
            self.logger.debug('Finishing test execution early due to phase '
                              'timeout, outcome TIMEOUT.')
            self.finalize(test_record.Outcome.TIMEOUT)
        elif phase_outcome.phase_result == openhtf.PhaseResult.STOP:
            self.logger.debug('Finishing test execution early due to '
                              'PhaseResult.STOP, outcome FAIL.')
            # TODO(madsci): Decouple flow control from pass/fail.
            self.finalize(test_record.Outcome.ABORTED)

        if self.is_finalized != phase_outcome.is_terminal:
            raise openhtf.InvalidTestStateError(
                'Unexpected finalized state (%s) after PhaseOutcome %s.',
                self.is_finalized, phase_outcome)
        return self.is_finalized

    def mark_test_started(self):
        """Set the TestRecord's start_time_millis field."""
        # Blow up instead of blowing away a previously set start_time_millis.
        assert self.test_record.start_time_millis is 0
        self.test_record.start_time_millis = util.time_millis()
        self.notify_update()

    def set_status_running(self):
        """Mark the test as actually running, can't be done once finalized."""
        assert self._status == self.Status.WAITING_FOR_TEST_START
        self._status = self.Status.RUNNING
        self.notify_update()

    def finalize(self, test_outcome=None):
        """Mark the state as finished.

    This method is called with no arguments on normal test completion, or
    with an argument if the test stopped under some other condition, where
    the test_outcome argument specifies what the Test's outcome was.

    When a Test completes normally, the outcome will be either PASS or FAIL,
    depending on measurements' PASS/FAIL status.  Any UNSET measurements will
    cause the Test to FAIL unless conf.allow_unset_measurements is set True.

    Args:
      test_outcome: If specified, use this as the Test outcome.
    """
        assert not self.is_finalized, 'Test already completed!'

        # Sanity check to make sure we have a DUT ID by the end of the test.
        if not self.test_record.dut_id:
            raise BlankDutIdError(
                'Blank or missing DUT ID, HTF requires a non-blank ID.')

        if test_outcome:
            # Override measurement-based PASS/FAIL with a specific test outcome.
            self.test_record.outcome = test_outcome
        else:
            allowed_outcomes = {measurements.Outcome.PASS}
            if conf.allow_unset_measurements:
                allowed_outcomes.add(measurements.Outcome.UNSET)

            if any(meas.outcome not in allowed_outcomes
                   for phase in self.test_record.phases
                   for meas in phase.measurements.itervalues()):
                self.test_record.outcome = test_record.Outcome.FAIL
            else:
                self.test_record.outcome = test_record.Outcome.PASS
            # A message has already been logged if we were called with test_outcome
            # set, but if we're finishing normally, log it here.
            self.logger.debug(
                'Finishing test execution normally with outcome %s.',
                self.test_record.outcome.name)

        # The test is done at this point, no further updates to test_record.
        self.logger.handlers = []
        self.test_record.end_time_millis = util.time_millis()
        self._status = self.Status.COMPLETED
        self.notify_update()

    def __str__(self):
        return '<%s: %s@%s Running Phase: %s>' % (
            type(self).__name__,
            self.test_record.dut_id,
            self.test_record.station_id,
            self.last_run_phase_name,
        )
# along with this program.  If not, see <http://www.gnu.org/licenses/>.



"""
Usage: streamparser.py [FILE]

Consumes input from a file (first argument) or stdin, parsing and pretty printing the readings of lexical units found.
"""

import re, pprint, sys, itertools, fileinput
from enum import Enum
from collections import namedtuple


Knownness = Enum('Knownness', 'known unknown biunknown genunknown')
try:
    Knownness.__doc__ = """Level of knowledge associated with a lexical unit.
    Values:
        known
        unknown: Denoted by '*', analysis not available.
        biunknown: Denoted by '@', translation not available.
        genunknown: Denoted by '#', generated form not available.
"""
except AttributeError:
    # Python 3.2 users have to read the source
    pass

SReading = namedtuple('SReading', ['baseform', 'tags'])
try:
    SReading.__doc__ = """A single subreading of an analysis of a token.
Пример #32
0
# coding: utf-8

from enum import Enum
import time

PizzaProgress = Enum('PizzaProgress', 'queued preparation baking ready')
PizzaDough = Enum('PizzaDough', 'thin thick')
PizzaSauce = Enum('PizzaSauce', 'tomato creme_fraiche')
PizzaTopping = Enum('PizzaTopping', 'mozzarella double_mozzarella bacon ham mushrooms red_onion oregano')
STEP_DELAY = 3          # 考虑是示例,单位为秒

# 这里没有一个AbstractBuilder

class Pizza:

    def __init__(self, name):
        self.name = name
        self.dough = None
        self.sauce = None
        self.topping = []

    def __str__(self):
        return self.name

    def prepare_dough(self, dough):
        self.dough = dough
        print('preparing the {} dough of your {}...'.format(self.dough.name, self))
        time.sleep(STEP_DELAY)
        print('done with the {} dough'.format(self.dough.name))

# ConcreateBuilder
Пример #33
0
# coding=utf-8

"""
Evaluation (t-tree comparison functions).
"""

from __future__ import unicode_literals
from collections import defaultdict
from enum import Enum
from tgen.logf import log_debug
from tgen.tree import TreeData, TreeNode
import numpy as np
from alex.components.nlg.tectotpl.core.node import T


EvalTypes = Enum(b'EvalTypes', b'NODE DEP')
EvalTypes.__doc__ = """Evaluation flavors (node-only, dependency)"""


def collect_counts(ttree, eval_type=EvalTypes.NODE):
    """Collects counts of different node/dependency types in the given t-tree.

    @param ttree: the tree to collect counts from
    @param eval_type: if set to 'node' (default), count nodes (formemes, lemmas, dependency \
        direction), if set to 'dep', count dependencies (including parent's formeme, lemma, \
        dependency direction).
    @rtype: defaultdict
    """
    counts = defaultdict(int)
    for node in ttree.get_descendants():
        if eval_type == EvalTypes.NODE:
Пример #34
0
    """Returns a function that prepends the supplied prefix and converts
  underscores to the dashes required by Cloud constants..

  """
    def inner(name: str) -> str:
        return "{}-{}".format(prefix, name.replace('_', '-'))

    return inner


US_REGIONS = {"west1", "west2", "central1", "east1", "east4"}
EURO_REGIONS = {"west1", "west4", "north1"}
ASIA_REGIONS = {"southeast1", "east1", "northeast1"}

# Actual enum types.
US = Enum('US', u.dict_by(US_REGIONS, _vfn("us")))
Europe = Enum('Europe', u.dict_by(EURO_REGIONS, _vfn("europe")))
Asia = Enum('Asia', u.dict_by(ASIA_REGIONS, _vfn("asia")))
Region = Union[US, Europe, Asia]
Zone = str


def valid_regions(zone: Optional[str] = None) -> List[Region]:
    """Returns valid region strings for Cloud, for the globe or for a particular
  region if specified.

  """
    if zone is None:
        return valid_regions("americas") \
          + valid_regions("europe") \
          + valid_regions("asia")
Пример #35
0
__author__ = 'Kaike'
from models import *
from enum import Enum

## kind

tKinds = ["NO_KIND_DEF", "VAR_", "PARAM_", "FUNCTION_", "FIELD_", "ARRAY_TYPE_", "STRUCT_TYPE_",
          "ALIAS_TYPE_", "SCALAR_TYPE_" , "UNIVERSAL_"]

Kinds = Enum._create_('Kinds', tKinds, None, int)

int_ = Object(-1, None, Kinds.SCALAR_TYPE_)
char_ = Object(-1, None, Kinds.SCALAR_TYPE_)
bool_ = Object(-1, None, Kinds.SCALAR_TYPE_)
string_ = Object(-1, None, Kinds.SCALAR_TYPE_)
universal_ = Object(-1, None, Kinds.SCALAR_TYPE_)


def IS_TYPE_KIND(k):
    return k == Kinds.ARRAY_TYPE_ or k == Kinds.STRUCT_TYPE_ or k == Kinds.ALIAS_TYPE_ or k == Kinds.SCALAR_TYPE_

def CheckTypes(self, t1, t2):
    if(t1 == t2):
        return True
    elif(t1 == universal_ or t2 == universal_):
        return True

    elif(t1.eKind == Kinds.UNIVERSAL_ or t2.eKind == Kinds.UNIVERSAL_):
        return True

    elif(t1.eKind == Kinds.ALIAS_TYPE_ and t2.eKind != Kinds.ALIAS_TYPE_):
Пример #36
0
    'Const',
    'Gather',
    'StridedSlice',
    'Slice',
    'ReverseV2',
    'Stack',
    'Pack',
    'Unstack',
    'Unpack',
    'Cast',
    'ArgMax',
    'Split',
    'FakeQuantWithMinMaxVars',
]

TFOpType = Enum('TFOpType', [(op, op) for op in TFSupportedOps], type=str)

TFSupportedOps = [six.b(op) for op in TFSupportedOps]

TFTransformGraphOptions = {
    base_converter.DeviceType.CPU.value: [
        'strip_unused_nodes', 'remove_nodes(op=Identity, op=CheckNumerics)',
        'fold_constants(ignore_errors=true)', 'fold_batch_norms',
        'fold_old_batch_norms', 'remove_control_dependencies',
        'strip_unused_nodes', 'sort_by_execution_order'
    ],
    base_converter.DeviceType.GPU.value: [
        'strip_unused_nodes', 'remove_nodes(op=Identity, op=CheckNumerics)',
        'fold_constants(ignore_errors=true)', 'flatten_atrous_conv',
        'fold_batch_norms', 'fold_old_batch_norms',
        'remove_control_dependencies', 'strip_unused_nodes',
Пример #37
0
# $Id: core.py 677 2012-01-12 17:46:11Z gnoel $
import datetime
import calendar
import re
from enum import Enum

modifiers = Enum()
modifiers.addElement('DEFAULT', {'symbol': ''})
modifiers.addElement('CIRCA', {'symbol': 'c. '})
modifiers.addElement('UNCERTAIN', {'symbol': '?'})

# date1 <= date <= date2 
# represents an approximate date into an inclusive date range
# Please run the regression test after modifying the code to make sure it is bug-free
# See tester.py
#
# Todo:
#    comparison
#    support 196* or 12** format
#    notes
#    before X
#    after X
#    BC
#    less than 4 digits for the year
#
class FuzzyDate(object):
    dates = [datetime.date.today(), datetime.date.today()]
    modifier = modifiers.DEFAULT
    lastError = u''
    # if False the format is iso-8109
    ukFormat = True
Пример #38
0
    'arm64',
    'armhf',
    'host',
]

ModelFormatStrs = [
    "file",
    "code",
]

PlatformTypeStrs = [
    "tensorflow",
    "caffe",
    "onnx",
]
PlatformType = Enum('PlatformType', [(ele, ele) for ele in PlatformTypeStrs],
                    type=str)

RuntimeTypeStrs = ["cpu", "gpu", "dsp", "hta", "apu", "cpu+gpu"]

InOutDataTypeStrs = [
    "int32",
    "float32",
]

InOutDataType = Enum('InputDataType',
                     [(ele, ele) for ele in InOutDataTypeStrs],
                     type=str)

FPDataTypeStrs = [
    "fp16_fp32",
    "fp32_fp32",
Пример #39
0
import math
import threading
import sys
from random import choice
from enum import Enum

# DFS Meta Data
CHUNK_SIZE = 2 * 1024 * 1024
BUFSIZE = 4 * 1024 * 1024
NUM_DATA_SERVER = 4
NUM_REPLICATION = 4
# Data Node Addr
DATA_NODE_ADDR = [
    '121.37.138.6', '124.70.177.49', '124.70.128.29', '124.70.153.253'
]
DATA_NODE_PORT = 20000
CHUNK_PATTERN = 'file-%s-%s'

TIME_OUT = 3

SYSTEM_Mode = 'DISTRIBUTED'  # LOCAL/DISTRIBUTED  本地/分布式

# Name Node Meta Data
NAME_NODE_META_PATH = './dfs/namenode/meta.pkl'
# Local Data Node
DATA_NODE_DIR = './dfs/datanode%s'

# Operations
operation_names = ('put', 'read', 'fetch', 'quit', 'ls', 'delete', 'll')
COMMAND = Enum('COMMAND', operation_names)
Пример #40
0
def run_mpi_sim(args,
                numbermodelruns,
                inputfile,
                usernamespace,
                optparams=None):
    """Run mixed mode MPI/OpenMP simulation - MPI task farm for models with each model parallelised with OpenMP

    Args:
        args (dict): Namespace with command line arguments
        numbermodelruns (int): Total number of model runs.
        inputfile (str): Name of the input file to open.
        usernamespace (dict): Namespace that can be accessed by user in any Python code blocks in input file.
        optparams (dict): Optional argument. For Taguchi optimisation it provides the parameters to optimise and their values.
    """

    from mpi4py import MPI

    # Define MPI message tags
    tags = Enum('tags', {'READY': 0, 'DONE': 1, 'EXIT': 2, 'START': 3})

    # Initializations and preliminaries
    comm = MPI.COMM_WORLD  # get MPI communicator object
    size = comm.Get_size()  # total number of processes
    rank = comm.Get_rank()  # rank of this process
    status = MPI.Status()  # get MPI status object
    name = MPI.Get_processor_name()  # get name of processor/host

    tsimstart = perf_counter()

    # Master process
    if rank == 0:
        modelrun = 1
        numworkers = size - 1
        closedworkers = 0
        print('Master: PID {} on {} using {} workers.'.format(
            os.getpid(), name, numworkers))
        while closedworkers < numworkers:
            data = comm.recv(source=MPI.ANY_SOURCE,
                             tag=MPI.ANY_TAG,
                             status=status)
            source = status.Get_source()
            tag = status.Get_tag()

            if tag == tags.READY.value:  # Worker is ready, so send it a task
                if modelrun < numbermodelruns + 1:
                    comm.send(modelrun, dest=source, tag=tags.START.value)
                    print('Master: sending model {} to worker {}.'.format(
                        modelrun, source))
                    modelrun += 1
                else:
                    comm.send(None, dest=source, tag=tags.EXIT.value)

            elif tag == tags.DONE.value:
                print('Worker {}: completed.'.format(source))

            elif tag == tags.EXIT.value:
                print('Worker {}: exited.'.format(source))
                closedworkers += 1

    # Worker process
    else:
        print('Worker {}: PID {} on {}.'.format(rank, os.getpid(), name))
        while True:
            comm.send(None, dest=0, tag=tags.READY.value)
            modelrun = comm.recv(
                source=0, tag=MPI.ANY_TAG, status=status
            )  #  Receive a model number to run from the master
            tag = status.Get_tag()

            # Run a model
            if tag == tags.START.value:
                if optparams:  # If Taguchi optimistaion, add specific value for each parameter to optimise for each experiment to user accessible namespace
                    tmp = {}
                    tmp.update((key, value[modelrun - 1])
                               for key, value in optparams.items())
                    modelusernamespace = usernamespace.copy()
                    modelusernamespace.update({'optparams': tmp})
                else:
                    modelusernamespace = usernamespace

                run_model(args, modelrun, numbermodelruns, inputfile,
                          modelusernamespace)
                comm.send(None, dest=0, tag=tags.DONE.value)

            elif tag == tags.EXIT.value:
                break

        comm.send(None, dest=0, tag=tags.EXIT.value)

    tsimend = perf_counter()
    simcompletestr = '\n=== Simulation completed in [HH:MM:SS]: {}'.format(
        datetime.timedelta(seconds=int(tsimend - tsimstart)))
    print('{} {}\n'.format(
        simcompletestr,
        '=' * (get_terminal_width() - 1 - len(simcompletestr))))
Пример #41
0
import trp
from typing import List, Optional
from tabulate import tabulate
from enum import Enum
from io import StringIO
import csv
import logging

logger = logging.getLogger(__name__)

Textract_Pretty_Print = Enum('Textract_Pretty_Print',
                             ["WORDS", "LINES", "FORMS", "TABLES"],
                             start=0)
Pretty_Print_Table_Format = Enum('Pretty_Print_Table_Format', [
    "csv", "plain", "simple", "github", "grid", "fancy_grid", "pipe", "orgtbl",
    "jira", "presto", "pretty", "psql", "rst", "mediawiki", "moinmoin",
    "youtrack", "html", "unsafehtml", "latex", "latex_raw", "latex_booktabs",
    "latex_longtable", "textile", "tsv"
])


def get_string(
    textract_json: dict,
    output_type: Optional[List[Textract_Pretty_Print]] = None,
    table_format: Pretty_Print_Table_Format = Pretty_Print_Table_Format.github
):
    result_value = ""
    for t in output_type:
        if t == Textract_Pretty_Print.WORDS:
            result_value += get_words_string(textract_json=textract_json)
        if t == Textract_Pretty_Print.LINES:
BG_DIR          = os.path.join(GFX_DIR, "bg")
BGD_DIR         = os.path.join(GFX_DIR, "bgd")
CUTIN_DIR       = os.path.join(GFX_DIR, "cutin")
EVENT_DIR       = os.path.join(GFX_DIR, "events")
FLASH_DIR       = os.path.join(GFX_DIR, "flash")
FONT_FOLDER     = os.path.join(GFX_DIR, "font")
MENU_DIR        = os.path.join(GFX_DIR, "menu")
MOVIEFRAME_DIR  = os.path.join(GFX_DIR, "movieframes") # Full-sized background frames
MOVIE_DIR       = os.path.join(GFX_DIR, "movies") # Icons for the movie gallery
NAMETAG_DIR     = os.path.join(GFX_DIR, "nametags")
PRESENT_DIR     = os.path.join(GFX_DIR, "presents")
SPRITE_DIR      = os.path.join(GFX_DIR, "sprites")
TEXTBOX_DIR     = os.path.join(GFX_DIR, "textbox")
TRIAL_DIR       = os.path.join(GFX_DIR, "trial")

TEXT_ALIGN   = Enum("left", "right", "center", "offcenter")
#TEXT_V_ALIGN = Enum("normal", "nonstop")
IMG_FILTERS  = Enum("unfiltered", "sepia", "inverted")

#SCENE_MODES = Enum("normal", "trial", "rules", "ammo", "ammoname", "present", "presentname", "debate", "mtb", "climax", "anagram", "menu", "map", "report", "report2", "skill", "skill2", "music", "eventname", "moviename", "theatre", "help", "other")
TEXT_FORMAT = {
  common.SCENE_MODES.normal:      {"x":  18, "y": 202, "w": 444, "h": 24, "a": TEXT_ALIGN.left,   "clt":  0, "killblanks": True},
  common.SCENE_MODES.trial:       {"x":  18, "y": 202, "w": 444, "h": 24, "a": TEXT_ALIGN.left,   "clt":  0, "killblanks": True},
  common.SCENE_MODES.rules:       {"x":  32, "y": 159, "w": 416, "h": 18, "a": TEXT_ALIGN.center, "clt":  0, "killblanks": True},
  common.SCENE_MODES.ammo:        {"x": 247, "y":  72, "w": 185, "h": 14, "a": TEXT_ALIGN.left,   "clt":  7, "killblanks": False},
  common.SCENE_MODES.ammoname:    {"x":  32, "y": 199, "w": 200, "h": 14, "a": TEXT_ALIGN.center, "clt":  7, "killblanks": True},
  common.SCENE_MODES.ammosummary: {"x":  41, "y": 192, "w": 200, "h": 12, "a": TEXT_ALIGN.left,   "clt":  7, "killblanks": False},
  common.SCENE_MODES.present:     {"x": 247, "y":  72, "w": 185, "h": 14, "a": TEXT_ALIGN.left,   "clt":  7, "killblanks": False},
  common.SCENE_MODES.presentname: {"x":  32, "y": 199, "w": 200, "h": 14, "a": TEXT_ALIGN.center, "clt":  7, "killblanks": True},
  common.SCENE_MODES.debate:      {"x":  18, "y": 160, "w": 444, "h": 24, "a": TEXT_ALIGN.center, "clt":  8, "killblanks": True},
  common.SCENE_MODES.mtb:         {"x":  18, "y": 160, "w": 444, "h": 24, "a": TEXT_ALIGN.center, "clt": 12, "killblanks": True},
Пример #43
0
	               , 'uint': 'u'
	               , 'float': ''
	               , 'double': 'd' }
	__machine_types__ = {'bool': dtype('uint32')
						,'int': dtype('int32')
						,'uint': dtype('uint32')
						,'float': dtype('float32')
						,'double': dtype('float64')}

	def __init__(self, value):
		self.prefix = self.__prefixes__[self.name]
		self.machine_type = self.__machine_types__[self.name]
		self.scalar_type = self
		self.opaque = False
scalar_doc = Scalar.__doc__
Scalar = Enum('Scalar', ((s, s) for s in scalar_types), type=Scalar)
Scalar.__doc__ = scalar_doc

floating_point_scalars = { Scalar.float, Scalar.double }

sampler_dims = range(1, 4)
sampler_data_types = {Scalar.float, Scalar.int, Scalar.uint}
sampler_types = [ "{}sampler{}D".format(scalar_type.prefix, ndim)
                  for scalar_type, ndim in cartesian(sampler_data_types, sampler_dims) ]
class Sampler(str, BasicType, Enum):
	'''The GLSL sampler types.

	Scalars difine the following attributes:

	*opaque*
	  Whether the datatype is an opaque type (:py:obj:`True`)
Пример #44
0
:License: Modified BSD, see LICENSE for details.
"""

from enum import Enum

from flask import current_app


EXTENSION_KEY = 'byceps'
KEY_SITE_MODE = 'site_mode'
KEY_PARTY_ID = 'party_id'
KEY_TICKET_MANAGEMENT_ENABLED = 'ticket_management_enabled'
KEY_USER_REGISTRATION_ENABLED = 'user_registration_enabled'


SiteMode = Enum('SiteMode', ['public', 'admin'])
SiteMode.is_admin = lambda self: self == SiteMode.admin
SiteMode.is_public = lambda self: self == SiteMode.public


def init_app(app):
    app.extensions[EXTENSION_KEY] = {}

    site_mode = determine_site_mode(app)
    update_extension_value(app, KEY_SITE_MODE, site_mode)

    if site_mode.is_public():
        party_id = determine_party_id(app)
        update_extension_value(app, KEY_PARTY_ID, party_id)

    user_registration_enabled = determine_user_registration_enabled(app,
Пример #45
0
# -*- coding: utf-8 -*-
# _author_='HAN'

import os
import const
from enum import Enum, unique

@unique
class LimitedOutputDirective(Enum):
    notLimited = 0
    limitedOutput = 1
table_type_t = Enum('table_type_t', ('byPtr', 'byU32', 'byU16'))
dict_directive = Enum('dict_directive', ('noDict', 'withPrefix64k', 'usingExtDict'))
dict_directive.noDict = 0
dictIssue_directive = Enum('dictIssue_directive', ('noDictIssue', 'dictSmall'))
dictIssue_directive.noDictIssue = 0


class EndConditionDirective(Enum):
    endOnOutputSize = 0
    endOnInputSize = 1


class EarlyEndDirective(Enum):
    full = 0
    partial = 1


const.memory_usage = 14
const.lz4_hash_log = 12
const.hash_table_size = 2 ^ 14
Пример #46
0
from enum import Enum
import threading
import time
CaptureMode = Enum('CaptureMode', 'Win32UI mss')

CAPTURE_MODE = CaptureMode.Win32UI

if CAPTURE_MODE == CaptureMode.Win32UI:
    from Model.ImageCaptureWin32UI import ImageCapture
else:
    from Model.ImageCaptureMSS import ImageCapture

import Networking.StoppableThread as StoppableThread


class ThreadedWinCapture(StoppableThread.StoppableThread):
    def __init__(self, *args):
        self.captureArgs = None
        self.currentImage = None
        self.imageId = 0
        self.captureArgLock = threading.Lock()
        self.imageLock = threading.Lock()
        super().__init__(*args)

    def setCaptureArgs(self, captureArgs):
        self.captureArgLock.acquire()
        self.captureArgs = captureArgs
        self.captureArgLock.release()

    def getCaptureArgs(self):
        self.captureArgLock.acquire()
Пример #47
0

@enum.unique
class Patterns(Enum):
  """
  Defines some known regex pattern templates for common types of inline syntax.
  For example, a single group inline element (one capture group framed by
  something before and after the group).
  """
  escape = '(?<!\\\\)(?:\\\\\\\\)*{0}'
  single_group = '(?<!\\\\)(?:\\\\\\\\)*\\K{0}(.*?(?<!\\\\)(?:\\\\\\\\)*){1}'
  link = r'(?<!\\)(?:\\\\)*\K{0}\[(.*?(?<!\\)(?:\\\\)*)\]\((.*?(?<!\\)(?:\\\\)*)\)'
  double_group = r'(?<!\\)(?:\\\\)*\K\{0}(.*?(?<!\\)(?:\\\\)*){1}(.*?(?<!\\)(?:\\\\)*){2}'


Nesting = Enum('Nesting', 'FRAME POST SUB NONE')
Nesting.__doc__ = """
FRAME: element is intended to contain/frame the inside
       text, which means that subscriptions should be inherited from the parent.

POST: text in the block should be parsed AFTER this block is
      parsed. This is the default, and is suitable for most situations.

SUB: the inside of the text is parsed for child nodes (inline and
     block) first, and the corresponding sections are replaced with [|*|] style
     tags that are meant to be left UNTOUCHED. After this block is parsed,
     then the tags are replaced with the appropriate parsed sections. This could
     have also been called 'PRE', since it pre-parses the contents before
     calling the block's parsing function.

NONE: terminal element. The parser's output is taken verbatim, with out any
Пример #48
0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License."""
__revision__ = " $Id: LingData.py 2 2017-07-25 14:32:00Z damir $ "
__docformat__ = 'reStructuredText'
__author__ = 'Damir Cavar <*****@*****.**>, Atreyee M.'
__version__ = '0.1'

from enum import Enum
#import PSTree

labels = Enum(
    'labels',
    'id word lemma POS SPOS NER foreign isReferent hasAntecedent RefText RefS RefFrom RefTo RefHead'
)
wtypes = Enum('wtypes', 'verb noun pronoun copula unknown')


def main():
    pass


class Document():
    """This is the main class that holds documents, which consist of a set of sentences.
    """
    def __init__(self):
        self.sentences = []  #: list of sentences
        self.sIDs = {
        }  #: dictionary with sentence IDs as keys and the sentence number in the list as value
Пример #49
0
 def setUp(self):
     super(TestEnum,self).setUp()
     self.Colors = Enum('Colors',['Red','Green','Blue'])
Пример #50
0
    except Exception as e:
        log.warning("Failed to convert attribute '%s'='%s': %s" % \
            (name, value, e))
        return default

def _write_xml_bbox(bbox, parent_elem):
    x, y, w, h = bbox
    bbox_elem = ET.SubElement(parent_elem, 'bndbox')
    ET.SubElement(bbox_elem, 'xmin').text = str(x)
    ET.SubElement(bbox_elem, 'ymin').text = str(y)
    ET.SubElement(bbox_elem, 'xmax').text = str(x + w)
    ET.SubElement(bbox_elem, 'ymax').text = str(y + h)
    return bbox_elem


LabelmapType = Enum('LabelmapType', ['voc', 'source'])

class VocConverter(Converter):
    DEFAULT_IMAGE_EXT = VocPath.IMAGE_EXT
    BUILTIN_ATTRS = {'difficult', 'pose', 'truncated', 'occluded' }

    @staticmethod
    def _split_tasks_string(s):
        return [VocTask[i.strip()] for i in s.split(',')]

    @staticmethod
    def _get_labelmap(s):
        if osp.isfile(s):
            return s
        try:
            return LabelmapType[s].name
Пример #51
0
#枚举类型
from enum import Enum
Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug',
                       'Sep', 'oct', 'Nov', 'Dec'))
for name, member in Month.__members__.items():
    print(name, '=>', member, ',', member.value)
Пример #52
0
class VW_EGolf(Device, HTTP):
    pass
    """
    the main class for the Golf charge device              /!\ actually unable to work
    """

    BASE  = "http://{h}/r?rapi=%24"
    Cmd   = Enum("Cmd", "sleep reset enable disable")

    __CmdToUrl = {
        Cmd.sleep:   "FS",
        Cmd.reset:   "FR",
        Cmd.enable:  "FE",
        Cmd.disable: "FD"
    }

    def __init__(self, host):
        """
        Construtor of the class VW_EGolf:
            :param host: the host of the charger
            :type host:  string
        """
        Device.__init__(self)
        BASE = BASE.format(h=host)
        self.__charging_rate = self.get_charging_rate()

    def command(self, cmd):
        """
        command to the charger:
            :param cmd: the command to pass to the charger
            :type cmd:  Cmd enum
            :return:    if it has been done or not
            :rtype:     bool
        """
        pass
        url    = BASE + __CmdToUrl[cmd]
        result = self._get(url)


    def get_charging_rate(self):
        """charging rate getter from the charger"""
        pass
        url    = BASE + "GC"
        result = self._get(url)
        #sort infos to get the value and return it

    @property
    def charging_rate(self):
        return __charging_rate

    @charging_rate.setter
    def set_charging_rate(self, charging_rate):
        """
        change the charging rate in ampere:
            :param charging_rate: new charging rate
            :type charging_rate: int
            :return:    if it has been done or not
            :rtype:     bool
        """
        pass
        url    = BASE + "SC+" + str(amp)
        result = self._get(url)
Пример #53
0
    'IB_EXACT_PREFIX',
])
ib_match_mode_t = c_int # XXX: unsure

class ib_col_meta_t(Structure):
    _fields_ = [
        ('type', ib_col_type_t),
        ('attr', ib_col_attr_t),
        ('type_len', ib_u32_t),
        ('client_type', ib_u16_t),
        ('charset', POINTER(ib_charset_t)),
    ]

ib_trx_state = Enum(globals(), [
    'IB_TRX_NOT_STARTED',
    'IB_TRX_ACTIVE',
    'IB_TRX_COMMITTED_IN_MEMORY',
    'IB_TRX_PREPARED',
])
ib_trx_state_t = c_int # XXX: unsure

ib_trx_level = Enum(globals(), [
    ('IB_TRX_READ_UNCOMMITTED', 0),
    ('IB_TRX_READ_COMMITTED', 1),
    ('IB_TRX_REPEATABLE_READ', 2),
    ('IB_TRX_SERIALIZABLE', 3),
])
ib_trx_level_t = c_int # XXX: unsure

ib_shutdown = Enum(globals(), [
    'IB_SHUTDOWN_NORMAL',
    'IB_SHUTDOWN_NO_IBUFMERGE_PURGE',
Пример #54
0
    def pad(self, word_amount: int, char_amount: int) -> None:
        if word_amount >= 0:
            self.X_words = np.pad(self.X_words, [(0, 0), (0, word_amount)],
                                  "constant")
        else:
            self.X_words = self.X_words[:, :word_amount]

        if char_amount >= 0:
            self.X_chars = np.pad(self.X_chars, [(0, 0), (0, char_amount)],
                                  "constant")
        else:
            self.X_chars = self.X_chars[:, :char_amount]


ClusterHandling = Enum("ClusterHandling", "CONCAT MEAN CENTER")


class GermanDataset(Dataset):
    def __init__(
            self,
            files: List[str],
            gmm_files: List[str],
            num_clusterlabels: int,
            num_gmm_clusters: int,
            window_before: int,
            window_after: int,
            word_vocab: Optional[Vocab] = None,
            char_vocab: Optional[Vocab] = None,
            bag_of_words: bool = False,
            cluster_handling: ClusterHandling = ClusterHandling.CONCAT