index int64 | repo_name string | branch_name string | path string | content string | import_graph string |
|---|---|---|---|---|---|
50,060 | corypaik/fancyflags | refs/heads/master | /fancyflags/examples/example_module.py | # Copyright 2021 DeepMind Technologies Limited.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.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.
# ============================================================================
"""A module that defines a dict flag, for testing purposes."""
import fancyflags as ff
ff.DEFINE_dict(
"settings",
integer_field=ff.Integer(1, "integer field"),
string_field=ff.String(None, "string field"),
)
| {"/fancyflags/_flags_test.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/example_module.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/override_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_flagsaver_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_argument_parsers_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions.py": ["/fancyflags/__init__.py"]} |
50,061 | corypaik/fancyflags | refs/heads/master | /fancyflags/_argument_parsers.py | # Copyright 2021 DeepMind Technologies Limited.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.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.
# ============================================================================
"""Argument parsers."""
import ast
import enum
from absl import flags
BASIC_SEQUENCE_TYPES = (list, tuple)
# We assume a sequence contains only these types. Python has no primitive types.
SIMPLE_TYPES = (bool, float, int, str)
NOT_A_SIMPLE_TYPE_MESSAGE = """
Input list contains unsupported type {{}}, however each element in a sequence
must be a {} or {}.
""".format(", ".join(type_.__name__ for type_ in SIMPLE_TYPES[:-1]),
SIMPLE_TYPES[-1].__name__)
class SequenceParser(flags.ArgumentParser):
"""Parser of simple sequences containing simple Python values."""
def parse(self, argument):
"""Parses the argument as a string-formatted sequence (list or tuple).
Essentially reverses the result of `"{}".format(a_sequence)`
Args:
argument: The flag value as a string, list, tuple or None. Examples of
valid input strings are `"(1,2,3)"` and `[0.2, 0.3, 1.0]`.
Returns:
The parsed sequence.
Raises:
TypeError: If the input type is not supported, or if the input is not a
flat sequence that only contains simple Python values.
"""
if argument is None:
return []
elif isinstance(argument, BASIC_SEQUENCE_TYPES):
result = argument[:]
elif isinstance(argument, str):
result = ast.literal_eval(argument)
if not isinstance(result, BASIC_SEQUENCE_TYPES):
raise TypeError(
"Input string should represent a list or tuple, however it "
"evaluated as a {}.".format(type(result).__name__))
else:
raise TypeError("Unsupported type {}.".format(type(argument).__name__))
# Make sure the result is a flat sequence of simple types.
for value in result:
if not isinstance(value, SIMPLE_TYPES):
raise TypeError(NOT_A_SIMPLE_TYPE_MESSAGE.format(type(value).__name__))
return result
def flag_type(self):
"""See base class."""
return "sequence"
class MultiEnumParser(flags.ArgumentParser):
"""Parser of multiple enum values.
This parser allows the flag values to be sequences of any type, unlike
flags.DEFINE_multi_enum which only allows strings.
"""
def __init__(self, enum_values):
if not enum_values:
raise ValueError("enum_values cannot be empty")
if any(not value for value in enum_values):
raise ValueError("No element of enum_values can be empty")
super().__init__()
self.enum_values = enum_values
def parse(self, arguments):
"""Determines validity of arguments.
Args:
arguments: list, tuple, or enum of flag values. Each value may be any type
Returns:
The input list, tuple or enum if valid.
Raises:
TypeError: If the input type is not supported.
ValueError: Raised if an argument element didn't match anything in enum.
"""
if arguments is None:
return []
elif isinstance(arguments, BASIC_SEQUENCE_TYPES):
result = arguments[:]
elif isinstance(arguments, enum.EnumMeta):
result = arguments
elif isinstance(arguments, str):
result = ast.literal_eval(arguments)
if not isinstance(result, BASIC_SEQUENCE_TYPES):
raise TypeError(
"Input string should represent a list or tuple, however it "
"evaluated as a {}.".format(type(result).__name__))
else:
raise TypeError("Unsupported type {}.".format(type(arguments).__name__))
if not all(arg in self.enum_values for arg in result):
raise ValueError("Argument values should be one of <{}>".format(
"|".join(str(value) for value in self.enum_values)))
else:
return result
def flag_type(self):
return "multi enum"
| {"/fancyflags/_flags_test.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/example_module.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/override_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_flagsaver_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_argument_parsers_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions.py": ["/fancyflags/__init__.py"]} |
50,062 | corypaik/fancyflags | refs/heads/master | /fancyflags/_auto.py | # Copyright 2021 DeepMind Technologies Limited.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.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.
# ============================================================================
"""Automatically builds flags from a callable signature."""
import inspect
from typing import Any, Callable, List, Mapping, Optional, Sequence, Tuple
from fancyflags import _definitions
# internal imports: usage_logging
# TODO(b/178129474): Improve support for typing.Sequence subtypes.
_TYPE_MAP = {
List[bool]: _definitions.Sequence,
List[float]: _definitions.Sequence,
List[int]: _definitions.Sequence,
List[str]: _definitions.Sequence,
Sequence[bool]: _definitions.Sequence,
Sequence[float]: _definitions.Sequence,
Sequence[int]: _definitions.Sequence,
Sequence[str]: _definitions.Sequence,
Tuple[bool]: _definitions.Sequence,
Tuple[float]: _definitions.Sequence,
Tuple[int]: _definitions.Sequence,
Tuple[str]: _definitions.Sequence,
bool: _definitions.Boolean,
float: _definitions.Float,
int: _definitions.Integer,
str: _definitions.String,
}
# Add optional versions of all types as well
_TYPE_MAP.update({Optional[tp]: parser for tp, parser in _TYPE_MAP.items()})
_MISSING_TYPE_ANNOTATION = "Missing type annotation for argument {name!r}"
_UNSUPPORTED_ARGUMENT_TYPE = (
"No matching flag type for argument {{name!r}} with type annotation: "
"{{annotation}}\n"
"Supported types:\n{}".format("\n".join(str(t) for t in _TYPE_MAP)))
_MISSING_DEFAULT_VALUE = "Missing default value for argument {name!r}"
def auto(callable_fn: Callable[..., Any]) -> Mapping[str, _definitions.Item]:
"""Automatically builds fancyflag definitions from a callable's signature.
Example usage:
```python
# Function
ff.DEFINE_dict('my_function_settings', **ff.auto(my_module.my_function))
# Class constructor
ff.DEFINE_dict('my_class_settings', **ff.auto(my_module.MyClass))
```
Args:
callable_fn: Generates flag definitions from this callable's signature. All
arguments must have type annotations and default values. The following
argument types are supported:
* `bool`, `float`, `int`, or `str` scalars
* Homogeneous sequences of these types
* Optional scalars or sequences of these types
Returns:
Mapping from parameter names to fancyflags `Item`s, to be splatted into
`ff.DEFINE_dict`.
Raises:
ValueError: If any of the arguments to `callable_fn` lacks a default value.
TypeError: If any of the arguments to `callable_fn` lacks a type annotation.
TypeError: If any of the arguments to `callable_fn` has an unsupported type.
"""
# usage_logging: auto
ff_dict = {}
# Work around issue with metaclass-wrapped classes, such as Sonnet v2 modules.
if isinstance(callable_fn, type):
signature = inspect.signature(callable_fn.__init__)
# Remove `self` from start of __init__ signature.
parameters = list(signature.parameters.values())[1:]
else:
signature = inspect.signature(callable_fn)
parameters = signature.parameters.values()
for param in parameters:
if param.annotation is inspect.Signature.empty:
raise TypeError(_MISSING_TYPE_ANNOTATION.format(name=param.name))
try:
ff_type = _TYPE_MAP[param.annotation]
except KeyError:
raise TypeError(_UNSUPPORTED_ARGUMENT_TYPE.format(
name=param.name, annotation=param.annotation))
if param.default is inspect.Signature.empty:
raise ValueError(_MISSING_DEFAULT_VALUE.format(name=param.name))
help_string = param.name # TODO(b/177673667): Parse this from docstring.
ff_dict[param.name] = ff_type(param.default, help_string)
return ff_dict
| {"/fancyflags/_flags_test.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/example_module.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/override_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_flagsaver_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_argument_parsers_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions.py": ["/fancyflags/__init__.py"]} |
50,063 | corypaik/fancyflags | refs/heads/master | /fancyflags/_define_auto_test.py | # Copyright 2021 DeepMind Technologies Limited.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.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.
# ============================================================================
"""Tests for fancyflags._define_auto."""
import copy
from typing import Sequence
from absl import flags
from absl.testing import absltest
import dataclasses
from fancyflags import _define_auto
from fancyflags import _flags
@dataclasses.dataclass
class Point:
x: float = 0.0
y: float = 0.0
label: str = ''
def greet(greeting: str = 'Hello', targets: Sequence[str] = ('world',)) -> str:
return greeting + ' ' + ', '.join(targets)
class DefineAutoTest(absltest.TestCase):
def test_dataclass(self):
flag_values = flags.FlagValues()
flag_holder = _define_auto.DEFINE_auto(
'point', Point, 'help string', flag_values=flag_values)
flag_values(('./program',
'--point.x=2.0', '--point.y=-1.5', '--point.label=p'))
expected = Point(2.0, -1.5, 'p')
self.assertEqual(expected, flag_holder.value())
def test_function(self):
flag_values = flags.FlagValues()
flag_holder = _define_auto.DEFINE_auto(
'greet', greet, 'help string', flag_values=flag_values)
flag_values(('./program',
'--greet.greeting=Hi there',
'--greet.targets=(\'Alice\', \'Bob\')'))
expected = 'Hi there Alice, Bob'
self.assertEqual(expected, flag_holder.value())
def test_override_kwargs(self):
flag_values = flags.FlagValues()
flag_holder = _define_auto.DEFINE_auto(
'point', Point, 'help string', flag_values=flag_values)
flag_values(('./program',
'--point.x=2.0', '--point.y=-1.5', '--point.label=p'))
expected = Point(3.0, -1.5, 'p')
# Here we override one of the arguments.
self.assertEqual(expected, flag_holder.value(x=3.0))
def test_overriding_top_level_auto_flag_fails(self):
flag_values = flags.FlagValues()
_define_auto.DEFINE_auto(
'point', Point, 'help string', flag_values=flag_values)
with self.assertRaisesRegex(flags.IllegalFlagValueError,
'Can\'t override an auto flag directly'):
flag_values(('./program', '--point=2.0'))
def test_basic_serialization(self):
flag_values = flags.FlagValues()
_define_auto.DEFINE_auto(
'point', Point, 'help string', flag_values=flag_values)
# Accessing flag_holder.value would raise an error here, since flags haven't
# been parsed yet. For consistency we access the value via flag_values
# throughout the test, rather than through a returned `FlagHolder`.
initial_point_value = copy.deepcopy(flag_values['point'].value())
# Parse flags, then serialize.
flag_values(('./program',
'--point.x=1.2', '--point.y=3.5', '--point.label=p'))
self.assertEqual(flag_values['point'].serialize(), _flags._EMPTY)
self.assertEqual(flag_values['point.x'].serialize(), '--point.x=1.2')
self.assertEqual(flag_values['point.label'].serialize(), '--point.label=p')
parsed_point_value = copy.deepcopy(flag_values['point'].value())
self.assertEqual(parsed_point_value, Point(x=1.2, y=3.5, label='p'))
self.assertNotEqual(parsed_point_value, initial_point_value)
# Test a round trip.
serialized_args = [flag_values[name].serialize()
for name in flag_values if name.startswith('point.')]
flag_values.unparse_flags() # Reset to defaults
self.assertEqual(flag_values['point'].value(), initial_point_value)
flag_values(['./program'] + serialized_args)
self.assertEqual(flag_values['point'].value(), parsed_point_value)
if __name__ == '__main__':
absltest.main()
| {"/fancyflags/_flags_test.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/example_module.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/override_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_flagsaver_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_argument_parsers_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions.py": ["/fancyflags/__init__.py"]} |
50,064 | corypaik/fancyflags | refs/heads/master | /fancyflags/_define_auto.py | # Copyright 2021 DeepMind Technologies Limited.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.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.
# ============================================================================
"""Automatic flags via ff.auto-compatible callables."""
from typing import Callable, TypeVar
from absl import flags
from fancyflags import _auto
from fancyflags import _definitions
from fancyflags import _flags
_T = TypeVar('_T')
def DEFINE_auto( # pylint: disable=invalid-name
name: str,
fn: Callable[..., _T],
help_string: str,
flag_values: flags.FlagValues = flags.FLAGS,
) -> flags.FlagHolder[Callable[..., _T]]:
"""Defines a flag for an `ff.auto`-compatible constructor or callable.
Automatically defines a set of dotted `ff.Item` flags corresponding to the
constructor arguments and their default values.
Overriding the value of a dotted flag will update the arguments used to invoke
`fn`. This flag's value returns a callable `fn` with these values as bound
arguments,
Example usage:
```python
# Defined in, e.g., datasets library.
@dataclasses.dataclass
class DataSettings:
dataset_name: str = 'mnist'
split: str = 'train'
batch_size: int = 128
# In main script.
# Exposes flags: --data.dataset_name --data.split and --data.batch_size.
DATA_SETTINGS = ff.DEFINE_auto('data', datasets.DataSettings, 'Data config')
def main(argv):
# del argv # Unused.
dataset = datasets.load(DATA_SETTINGS.value())
# ...
```
Args:
name: The name for the top-level flag.
fn: An `ff.auto`-compatible `Callable`.
help_string: The help string for this flag.
flag_values: An optional `flags.FlagValues` instance.
Returns:
A `flags.FlagHolder`.
"""
arguments = _auto.auto(fn)
# Define the individual flags.
defaults = _definitions.define_flags(name, arguments, flag_values=flag_values)
# Define a holder flag.
return flags.DEFINE_flag(
_flags.AutoFlag(
fn,
defaults,
name=name,
default=None,
parser=flags.ArgumentParser(),
serializer=None,
help_string=help_string),
flag_values=flag_values)
| {"/fancyflags/_flags_test.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/example_module.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/override_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_flagsaver_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_argument_parsers_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions.py": ["/fancyflags/__init__.py"]} |
50,065 | corypaik/fancyflags | refs/heads/master | /fancyflags/examples/override_test.py | # Copyright 2021 DeepMind Technologies Limited.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.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.
# ============================================================================
"""Test for flag overrides in fancyflags.."""
from absl import flags
from absl.testing import absltest
import fancyflags as ff
SETTINGS = ff.DEFINE_dict(
"settings",
integer_field=ff.Integer(1, "integer field"),
string_field=ff.String(None, "string field"),
nested=dict(
float_field=ff.Float(0.0, "float field")
),
sequence_field=ff.Sequence([1, 2, 3], "sequence field"),
another_sequence_field=ff.Sequence((3.14, 2.718), "another sequence field"),
string_list_field=ff.StringList(["a"], "string list flag.")
)
class OverrideTest(absltest.TestCase):
def test_give_me_a_name(self):
expected = dict(
integer_field=5,
string_field=None, # Not overridden in BUILD args.
nested=dict(
float_field=3.2,
),
sequence_field=[4, 5, 6],
another_sequence_field=[3.0, 2.0],
string_list_field=["a", "bunch", "of", "overrides"],
)
self.assertEqual(flags.FLAGS.settings, expected)
self.assertEqual(SETTINGS.value, expected)
if __name__ == "__main__":
absltest.main()
| {"/fancyflags/_flags_test.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/example_module.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/override_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_flagsaver_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_argument_parsers_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions.py": ["/fancyflags/__init__.py"]} |
50,066 | corypaik/fancyflags | refs/heads/master | /fancyflags/_flags.py | # Copyright 2021 DeepMind Technologies Limited.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.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.
# ============================================================================
"""Flag classes for defining dict, Item, MultiItem and Auto flags."""
import copy
import functools
from absl import flags
_EMPTY = ""
class DictFlag(flags.Flag):
"""Implements the shared dict mechanism. See also `ItemFlag`."""
def __init__(self, shared_dict, *args, **kwargs):
self._shared_dict = shared_dict
super().__init__(*args, **kwargs)
def _parse(self, value):
# A `DictFlag` should not be overridable from the command line; only the
# dotted `Item` flags should be. However, the _parse() method will still be
# called in two situations:
# 1. Via the base `Flag`'s constructor, which calls `_parse()` to process
# the default value, which will be the shared dict.
# 2. When processing command line overrides. We don't want to allow this
# normally, however some libraries will serialize and deserialize all
# flags, e.g. to pass values between processes, so we accept a dummy
# empty serialized value for these cases. It's unlikely users will try to
# set the dict flag to an empty string from the command line.
if value is self._shared_dict or value == _EMPTY:
return self._shared_dict
raise flags.IllegalFlagValueError(
"Can't override a dict flag directly. Did you mean to override one of "
"its `Item`s instead?")
def serialize(self):
# When serializing flags, we return a sentinel value that the `DictFlag`
# will ignore when parsing. The value of this flag is determined by the
# corresponding `Item` flags for serialization and deserialization.
return _EMPTY
def flag_type(self):
return "dict"
# TODO(b/170423907): Pytype doesn't correctly infer that these have type
# `property`.
_flag_value_property = flags.Flag.value # type: property
_multi_flag_value_property = flags.MultiFlag.value # type: property
class ItemFlag(flags.Flag):
"""Updates a shared dict whenever its own value changes.
See also the `DictFlag` and `ff.Item` classes for usage.
"""
def __init__(self, shared_dict, namespace, *args, **kwargs):
self._shared_dict = shared_dict
self._namespace = namespace
super().__init__(*args, **kwargs)
# `super().value = value` doesn't work, see https://bugs.python.org/issue14965
@_flag_value_property.setter
def value(self, value):
_flag_value_property.fset(self, value)
self._update_shared_dict()
def parse(self, argument):
super().parse(argument)
self._update_shared_dict()
def _update_shared_dict(self):
d = self._shared_dict
for name in self._namespace[:-1]:
d = d[name]
d[self._namespace[-1]] = self.value
class MultiItemFlag(flags.MultiFlag):
"""Updates a shared dict whenever its own value changes.
Used for flags that can appear multiple times on the command line.
See also the `DictFlag` and `ff.Item` classes for usage.
"""
def __init__(self, shared_dict, namespace, *args, **kwargs):
self._shared_dict = shared_dict
self._namespace = namespace
super().__init__(*args, **kwargs)
# `super().value = value` doesn't work, see https://bugs.python.org/issue14965
@_multi_flag_value_property.setter
def value(self, value):
_multi_flag_value_property.fset(self, value)
self._update_shared_dict()
def parse(self, argument):
super().parse(argument)
self._update_shared_dict()
def _update_shared_dict(self):
d = self._shared_dict
for name in self._namespace[:-1]:
d = d[name]
d[self._namespace[-1]] = self.value
class AutoFlag(flags.Flag):
"""Implements the shared dict mechanism."""
def __init__(self, fn, fn_kwargs, *args, **kwargs):
self._fn = fn
self._fn_kwargs = fn_kwargs
super().__init__(*args, **kwargs)
@property
def value(self):
kwargs = copy.deepcopy(self._fn_kwargs)
return functools.partial(self._fn, **kwargs)
@value.setter
def value(self, value):
# The flags `.value` gets set as part of the `flags.FLAG` constructor to a
# default value. However the default value should be given by the initial
# `fn_kwargs` instead, so a) the semantics of setting the value are unclear
# and b) we may not be able to call `self._fn` at this point in execution.
del value
def _parse(self, value):
# An `AutoFlag` should not be overridable from the command line; only the
# dotted `Item` flags should be. However, the `_parse()` method will still
# be called in two situations:
# 1. In the base `Flag`'s constructor, which calls `_parse()` to process the
# default value, which will be None (as set in `DEFINE_auto`).
# 2. When processing command line overrides. We don't want to allow this
# normally, however some libraries will serialize and deserialize all
# flags, e.g. to pass values between processes, so we accept a dummy
# empty serialized value for these cases. It's unlikely users will try to
# set the auto flag to an empty string from the command line.
if value is None or value == _EMPTY:
return None
raise flags.IllegalFlagValueError(
"Can't override an auto flag directly. Did you mean to override one of "
"its `Item`s instead?")
def serialize(self):
# When serializing a `FlagHolder` container, we must return *some* value for
# this flag. We return an empty value that the `AutoFlag` will ignore when
# parsing. The value of this flag is instead determined by the
# corresponding `Item` flags for serialization and deserialization.
return _EMPTY
def flag_type(self):
return "auto"
| {"/fancyflags/_flags_test.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/example_module.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/override_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_flagsaver_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_argument_parsers_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions.py": ["/fancyflags/__init__.py"]} |
50,067 | corypaik/fancyflags | refs/heads/master | /fancyflags/__init__.py | # Copyright 2021 DeepMind Technologies Limited.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.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.
# ============================================================================
"""An extended flags library. The main component is a nested dict flag."""
from fancyflags import _auto
from fancyflags import _define_auto
from fancyflags import _definitions
from fancyflags import _metadata
# internal imports: usage_logging
__version__ = _metadata.__version__
# pylint: disable=invalid-name
# Function for automatically building fancyflags defs from a callable signature.
auto = _auto.auto
DEFINE_dict = _definitions.DEFINE_dict
define_flags = _definitions.define_flags
DEFINE_sequence = _definitions.DEFINE_sequence
DEFINE_auto = _define_auto.DEFINE_auto
# Currently supported types inside the dict.
Boolean = _definitions.Boolean
Enum = _definitions.Enum
EnumClass = _definitions.EnumClass
Float = _definitions.Float
Integer = _definitions.Integer
MultiEnum = _definitions.MultiEnum
MultiEnumClass = _definitions.MultiEnumClass
MultiString = _definitions.MultiString
Sequence = _definitions.Sequence
String = _definitions.String
StringList = _definitions.StringList
# Class for adding new flag types.
Item = _definitions.Item
# usage_logging: import
| {"/fancyflags/_flags_test.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/example_module.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/override_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_flagsaver_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_argument_parsers_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions.py": ["/fancyflags/__init__.py"]} |
50,068 | corypaik/fancyflags | refs/heads/master | /fancyflags/_auto_test.py | # Copyright 2021 DeepMind Technologies Limited.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.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.
# ============================================================================
"""Tests for fancyflags.auto."""
import abc
from typing import List, Optional, Sequence, Tuple
from absl import flags
from absl.testing import absltest
import fancyflags as ff
from fancyflags import _auto
FLAGS = flags.FLAGS
class AutoTest(absltest.TestCase):
def test_works_fn(self):
# pylint: disable=unused-argument
def my_function(
str_: str = 'foo',
int_: int = 10,
float_: float = 1.0,
bool_: bool = False,
list_int: List[int] = [1, 2, 3],
tuple_str: Tuple[str] = ('foo',),
sequence_bool: Sequence[bool] = [True, False],
optional_int: Optional[int] = None,
optional_float: Optional[float] = None,
optional_list_int: Optional[List[int]] = None,
): # pylint: disable=dangerous-default-value
pass
# pylint: enable=unused-argument
expected_settings = {
'str_': 'foo',
'int_': 10,
'float_': 1.0,
'bool_': False,
'list_int': [1, 2, 3],
'tuple_str': ('foo',),
'sequence_bool': [True, False],
'optional_int': None,
'optional_float': None,
'optional_list_int': None,
}
ff_dict = ff.auto(my_function)
self.assertCountEqual(expected_settings, ff_dict)
ff.DEFINE_dict('my_function_settings', **ff_dict)
self.assertEqual(FLAGS.my_function_settings, expected_settings)
def test_works_class(self):
class MyClass:
# pylint: disable=unused-argument
def __init__(
self,
str_: str = 'foo',
int_: int = 10,
float_: float = 1.0,
bool_: bool = False,
list_int: List[int] = [1, 2, 3],
tuple_str: Tuple[str] = ('foo',),
sequence_bool: Sequence[bool] = [True, False],
optional_int: Optional[int] = None,
optional_float: Optional[float] = None,
optional_list_int: Optional[List[int]] = None,
): # pylint: disable=dangerous-default-value
pass
# pylint: enable=unused-argument
expected_settings = {
'str_': 'foo',
'int_': 10,
'float_': 1.0,
'bool_': False,
'list_int': [1, 2, 3],
'tuple_str': ('foo',),
'sequence_bool': [True, False],
'optional_int': None,
'optional_float': None,
'optional_list_int': None,
}
ff_dict = ff.auto(MyClass)
self.assertCountEqual(expected_settings, ff_dict)
ff.DEFINE_dict('my_class_settings', **ff_dict)
self.assertEqual(FLAGS.my_class_settings, expected_settings)
def test_works_metaclass(self):
# This replicates an issue with Sonnet v2 modules, where the constructor
# arguments are hidden by the metaclass.
class MyMetaclass(abc.ABCMeta):
def __call__(cls, *args, **kwargs):
del args, kwargs
class MyClass(metaclass=MyMetaclass):
def __init__(self,
a: int = 10,
b: float = 1.0,
c: Sequence[int] = (1, 2, 3)):
del a, b, c
ff_dict = ff.auto(MyClass)
self.assertEqual(['a', 'b', 'c'], list(ff_dict))
ff.DEFINE_dict('my_meta_class_settings', **ff_dict)
self.assertEqual(FLAGS.my_meta_class_settings['a'], 10)
self.assertEqual(FLAGS.my_meta_class_settings['b'], 1.0)
self.assertEqual(FLAGS.my_meta_class_settings['c'], (1, 2, 3))
def test_error_if_missing_default_value(self):
def my_function(a: int, b: float = 1.0, c: Sequence[int] = (1, 2, 3)):
del a, b, c
with self.assertRaisesWithLiteralMatch(
ValueError, _auto._MISSING_DEFAULT_VALUE.format(name='a')):
ff.auto(my_function)
def test_error_if_missing_type_annotation(self):
def my_function(a: int = 10, b=1.0, c: Sequence[int] = (1, 2, 3)):
del a, b, c
with self.assertRaisesWithLiteralMatch(
TypeError, _auto._MISSING_TYPE_ANNOTATION.format(name='b')):
ff.auto(my_function)
def test_error_if_unsupported_type(self):
def my_function(a: int = 10,
b: float = 1.0,
c: Sequence[object] = (1, 2, 3)):
del a, b, c
with self.assertRaisesWithLiteralMatch(
TypeError,
_auto._UNSUPPORTED_ARGUMENT_TYPE.format(
name='c', annotation=Sequence[object])):
ff.auto(my_function)
# TODO(b/178129474): Improve support for typing.Sequence subtypes.
@absltest.expectedFailure
def test_supports_tuples_with_more_than_one_element(self):
def my_function(three_ints: Tuple[int, int, int] = (1, 2, 3),
zero_or_more_strings: Tuple[str, ...] = ('foo', 'bar')):
del three_ints, zero_or_more_strings
expected_settings = {
'three_ints': (1, 2, 3),
'zero_or_more_strings': ('foo', 'bar'),
}
ff_dict = ff.auto(my_function)
self.assertCountEqual(expected_settings, ff_dict)
ff.DEFINE_dict('my_function_settings', **ff_dict)
self.assertEqual(FLAGS.my_function_settings, expected_settings)
if __name__ == '__main__':
absltest.main()
| {"/fancyflags/_flags_test.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/example_module.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/override_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_flagsaver_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_argument_parsers_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions.py": ["/fancyflags/__init__.py"]} |
50,069 | corypaik/fancyflags | refs/heads/master | /fancyflags/_flagsaver_test.py | # Copyright 2021 DeepMind Technologies Limited.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.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.
# ============================================================================
"""Tests for compatibility with absl.testing.flagsaver."""
from absl import flags
from absl.testing import absltest
from absl.testing import flagsaver
import fancyflags as ff
flags.DEFINE_string("string_flag", "unchanged", "flag to test with")
ff.DEFINE_dict(
"test_dict_flag",
dict=dict(
nested=ff.Float(1.0, "nested flag"),
),
unnested=ff.Integer(4, "unnested flag"),
)
FLAGS = flags.FLAGS
class FlagSaverTest(absltest.TestCase):
def test_flagsaver_with_context_overrides(self):
with flagsaver.flagsaver(**{
"string_flag": "new value",
"test_dict_flag.dict.nested": -1.0,
}):
self.assertEqual("new value", FLAGS.string_flag)
self.assertEqual(-1.0, FLAGS.test_dict_flag["dict"]["nested"])
self.assertEqual(4, FLAGS.test_dict_flag["unnested"])
FLAGS.string_flag = "another value"
self.assertEqual("unchanged", FLAGS.string_flag)
self.assertEqual(1.0, FLAGS.test_dict_flag["dict"]["nested"])
def test_flagsaver_with_decorator_overrides(self):
# Modeled after test_decorator_with_overrides in
# https://github.com/abseil/abseil-py/blob/master/absl/testing/tests/flagsaver_test.py # pylint: disable=line-too-long
@flagsaver.flagsaver(**{
"string_flag": "new value",
"test_dict_flag.dict.nested": -1.0,
})
def mutate_flags():
return FLAGS.string_flag, FLAGS.test_dict_flag["dict"]["nested"]
# Values should be overridden in the function.
self.assertEqual(("new value", -1.0), mutate_flags())
# But unchanged here.
self.assertEqual("unchanged", FLAGS.string_flag)
self.assertEqual(1.0, FLAGS.test_dict_flag["dict"]["nested"])
def test_flagsaver_with_context_overrides_twice(self):
# Checking that the flat -> dict flag sync works again after restoration.
# This might fail if the underlying absl functions copied the dict as part
# of restoration.
with flagsaver.flagsaver(**{
"string_flag": "new value",
"test_dict_flag.dict.nested": -1.0,
}):
self.assertEqual("new value", FLAGS.string_flag)
self.assertEqual(-1.0, FLAGS.test_dict_flag["dict"]["nested"])
self.assertEqual(4, FLAGS.test_dict_flag["unnested"])
FLAGS.string_flag = "another value"
self.assertEqual("unchanged", FLAGS.string_flag)
self.assertEqual(1.0, FLAGS.test_dict_flag["dict"]["nested"])
# Same again!
with flagsaver.flagsaver(**{
"string_flag": "new value",
"test_dict_flag.dict.nested": -1.0,
}):
self.assertEqual("new value", FLAGS.string_flag)
self.assertEqual(-1.0, FLAGS.test_dict_flag["dict"]["nested"])
self.assertEqual(4, FLAGS.test_dict_flag["unnested"])
FLAGS.string_flag = "another value"
self.assertEqual("unchanged", FLAGS.string_flag)
self.assertEqual(1.0, FLAGS.test_dict_flag["dict"]["nested"])
@absltest.skip("This fails because flagsaver does not do deep copies")
def test_flagsaver_with_changes_within_context(self):
"""Overrides within a flagsaver context should be correctly restored."""
with flagsaver.flagsaver():
FLAGS.string_flag = "new_value"
FLAGS["test_dict_flag.dict.nested"].value = -1.0
FLAGS.test_dict_flag["unnested"] = -1.0
self.assertEqual("unchanged", FLAGS.string_flag) # Works.
self.assertEqual(1.0, FLAGS.test_dict_flag["dict"]["nested"]) # Works.
# TODO(b/177927157) Fix this behaviour.
self.assertEqual(4, FLAGS.test_dict_flag["unnested"]) # Broken.
if __name__ == "__main__":
absltest.main()
| {"/fancyflags/_flags_test.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/example_module.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/override_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_flagsaver_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_argument_parsers_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions.py": ["/fancyflags/__init__.py"]} |
50,070 | corypaik/fancyflags | refs/heads/master | /fancyflags/_definitions_test.py | # Copyright 2021 DeepMind Technologies Limited.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.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.
# ============================================================================
"""Tests for definitions."""
import copy
import enum
from absl import flags
from absl.testing import absltest
from absl.testing import parameterized
# definitions almost exactly corresponds to the public API, so aliasing the
# import here for better illustrative tests.
from fancyflags import _definitions as ff
from fancyflags import _flags
FLAGS = flags.FLAGS
class MyEnum(enum.Enum):
A = 1
B = 2
class DifferentEnum(enum.Enum):
C = 1
D = 2
class FancyflagsTest(absltest.TestCase):
def test_define_flat(self):
flagholder = ff.DEFINE_dict(
"flat_dict",
integer_field=ff.Integer(1, "integer field"),
string_field=ff.String(""),
string_list_field=ff.StringList(["a", "b", "c"], "string list field"))
# This should return a single dict with the default values specified above.
expected = {
"integer_field": 1,
"string_field": "",
"string_list_field": ["a", "b", "c"]
}
self.assertEqual(FLAGS.flat_dict, expected)
self.assertEqual(flagholder.value, expected)
# These flags should also exist, although we won't access them in practice.
self.assertEqual(FLAGS["flat_dict.integer_field"].value, 1)
self.assertEqual(FLAGS["flat_dict.string_field"].value, "")
# Custom help string.
self.assertEqual(FLAGS["flat_dict.integer_field"].help, "integer field")
# Default help string.
self.assertEqual(FLAGS["flat_dict.string_field"].help,
"flat_dict.string_field")
def test_define_nested(self):
flagholder = ff.DEFINE_dict(
"nested_dict",
integer_field=ff.Integer(1, "integer field"),
sub_dict=dict(
string_field=ff.String("", "string field")
)
)
# This should return a single dict with the default values specified above.
expected = {"integer_field": 1, "sub_dict": {"string_field": ""}}
self.assertEqual(FLAGS.nested_dict, expected)
self.assertEqual(flagholder.value, expected)
# These flags should also exist, although we won't access them in practice.
self.assertEqual(FLAGS["nested_dict.integer_field"].value, 1)
self.assertEqual(FLAGS["nested_dict.sub_dict.string_field"].value, "")
def test_no_name_error(self):
with self.assertRaisesRegex(ValueError, "one positional argument"):
ff.DEFINE_dict(
integer_field=ff.Integer(1, "integer field"),
)
def test_no_kwargs_error(self):
with self.assertRaisesRegex(ValueError, "one keyword argument"):
ff.DEFINE_dict("no_kwargs")
def test_too_many_positional_args_error(self):
with self.assertRaisesRegex(ValueError, "at most two positional"):
ff.DEFINE_dict(
"name",
ff.String("foo", "string"),
ff.String("bar", "string"),
integer_field=ff.Integer(1, "integer field")
)
def test_flag_name_error(self):
with self.assertRaisesRegex(ValueError, "must be a string"):
ff.DEFINE_dict(
ff.String("name", "string flag"),
ff.String("stringflag", "string"),
integer_field=ff.Integer(1, "integer field")
)
def test_flag_values_error(self):
with self.assertRaisesRegex(ValueError, "FlagValues instance"):
ff.DEFINE_dict(
"name",
ff.String("stringflag", "string"),
integer_field=ff.Integer(1, "integer field")
)
def test_define_valid_enum(self):
ff.DEFINE_dict(
"valid_enum",
padding=ff.Enum("same", ["same", "valid"], "enum field"),
)
self.assertEqual(FLAGS.valid_enum, {"padding": "same"})
def test_define_valid_case_insensitive_enum(self):
ff.DEFINE_dict(
"valid_case_sensitive",
padding=ff.Enum("Same", ["same", "valid"], "enum field",
case_sensitive=False),
)
self.assertEqual(FLAGS.valid_case_sensitive, {"padding": "same"})
def test_define_invalid_enum(self):
with self.assertRaises(ValueError):
ff.Enum("invalid", ["same", "valid"], "enum field")
def test_define_invalid_case_sensitive_enum(self):
with self.assertRaises(ValueError):
ff.Enum("Same", ["same", "valid"], "enum field")
def test_define_valid_enum_class(self):
ff.DEFINE_dict(
"valid_enum_class",
my_enum=ff.EnumClass(MyEnum.A, MyEnum, "enum class field")
)
self.assertEqual(FLAGS.valid_enum_class, {"my_enum": MyEnum.A})
def test_define_invalid_enum_class(self):
with self.assertRaises(TypeError):
ff.EnumClass("invalid_enum_class", DifferentEnum.C, MyEnum)
class ExtractDefaultsTest(absltest.TestCase):
def test_valid_flat(self):
result = ff._extract_defaults(
{
"integer_field": ff.Integer(10, "Integer field"),
"string_field": ff.String("default", "String field"),
}
)
expected = {"integer_field": 10, "string_field": "default"}
self.assertEqual(result, expected)
def test_valid_nested(self):
result = ff._extract_defaults(
{
"integer_field": ff.Integer(10, "Integer field"),
"string_field": ff.String("default", "String field"),
"nested": {
"float_field": ff.Float(3.1, "Float field"),
},
}
)
expected = {
"integer_field": 10,
"string_field": "default",
"nested": {"float_field": 3.1},
}
self.assertEqual(result, expected)
def test_invalid_container(self):
expected_message = ff._NOT_A_DICT_OR_ITEM.format("list")
with self.assertRaisesWithLiteralMatch(TypeError, expected_message):
ff._extract_defaults(
{
"integer_field": ff.Integer(10, "Integer field"),
"string_field": ff.String("default", "String field"),
"nested": [ff.Float(3.1, "Float field")],
}
)
def test_invalid_flat_leaf(self):
expected_message = ff._NOT_A_DICT_OR_ITEM.format("int")
with self.assertRaisesWithLiteralMatch(TypeError, expected_message):
ff._extract_defaults(
{
"string_field": ff.String("default", "String field"),
"naughty_field": 100,
}
)
def test_invalid_nested_leaf(self):
expected_message = ff._NOT_A_DICT_OR_ITEM.format("bool")
with self.assertRaisesWithLiteralMatch(TypeError, expected_message):
ff._extract_defaults(
{
"string_field": ff.String("default", "String field"),
"nested": {
"naughty_field": True,
},
}
)
def test_overriding_top_level_dict_flag_fails(self):
ff.DEFINE_dict(
"top_level_dict",
integer_field=ff.Integer(1, "integer field")
)
# The error type and message get converted in the process.
with self.assertRaisesRegex(flags.IllegalFlagValueError,
"Can't override a dict flag directly"):
FLAGS(("./program", "--top_level_dict=3"))
class SequenceTest(absltest.TestCase):
def test_sequence_defaults(self):
ff.DEFINE_dict(
"dict_with_sequences",
int_sequence=ff.Sequence([1, 2, 3], "integer field"),
float_sequence=ff.Sequence([3.14, 2.718], "float field"),
mixed_sequence=ff.Sequence([100, "hello", "world"], "mixed field")
)
self.assertEqual(FLAGS.dict_with_sequences,
{"int_sequence": [1, 2, 3],
"float_sequence": [3.14, 2.718],
"mixed_sequence": [100, "hello", "world"]})
class MultiEnumTest(parameterized.TestCase):
def test_defaults_parsing(self):
enum_values = [1, 2, 3, 3.14, 2.718, 100, "hello", ["world"], {"planets"}]
ff.DEFINE_dict(
"dict_with_multienums",
int_sequence=ff.MultiEnum([1, 2, 3], enum_values, "integer field"),
float_sequence=ff.MultiEnum([3.14, 2.718], enum_values, "float field"),
mixed_sequence=ff.MultiEnum([100, "hello", ["world"], {"planets"}],
enum_values, "mixed field"),
enum_sequence=ff.MultiEnum([MyEnum.A], MyEnum, "enum field")
)
self.assertEqual(FLAGS.dict_with_multienums,
{"int_sequence": [1, 2, 3],
"float_sequence": [3.14, 2.718],
"mixed_sequence": [100, "hello", ["world"], {"planets"}],
"enum_sequence": [MyEnum.A]})
class DefineSequenceTest(absltest.TestCase):
# Follows test code in absl/flags/tests/flags_test.py
def test_definition(self):
num_existing_flags = len(FLAGS)
ff.DEFINE_sequence("sequence", [1, 2, 3], "sequence flag")
self.assertLen(FLAGS, num_existing_flags + 1)
self.assertEqual(FLAGS.sequence, [1, 2, 3])
self.assertEqual(FLAGS.flag_values_dict()["sequence"], [1, 2, 3])
self.assertEqual(FLAGS["sequence"].default_as_str, "'[1, 2, 3]'") # pytype: disable=attribute-error
def test_parsing(self):
# There are more extensive tests for the parser in argument_parser_test.py.
# Here we just include a couple of end-to-end examples.
ff.DEFINE_sequence("sequence0", [1, 2, 3], "sequence flag")
FLAGS(("./program", "--sequence0=[4,5]"))
self.assertEqual(FLAGS.sequence0, [4, 5])
ff.DEFINE_sequence("sequence1", None, "sequence flag")
FLAGS(("./program", "--sequence1=(4, 5)"))
self.assertEqual(FLAGS.sequence1, (4, 5))
class DefineMultiEnumTest(absltest.TestCase):
# Follows test code in absl/flags/tests/flags_test.py
def test_definition(self):
num_existing_flags = len(FLAGS)
ff.DEFINE_multi_enum("multienum", [1, 2, 3], [1, 2, 3], "multienum flag")
self.assertLen(FLAGS, num_existing_flags + 1)
self.assertEqual(FLAGS.multienum, [1, 2, 3])
self.assertEqual(FLAGS.flag_values_dict()["multienum"], [1, 2, 3])
self.assertEqual(FLAGS["multienum"].default_as_str, "'[1, 2, 3]'") # pytype: disable=attribute-error
def test_parsing(self):
# There are more extensive tests for the parser in argument_parser_test.py.
# Here we just include a couple of end-to-end examples.
ff.DEFINE_multi_enum("multienum0", [1, 2, 3], [1, 2, 3, 4, 5],
"multienum flag")
FLAGS(("./program", "--multienum0=[4,5]"))
self.assertEqual(FLAGS.multienum0, [4, 5])
ff.DEFINE_multi_enum("multienum1", None, [1, 2, 3, 4, 5], "multienum flag")
FLAGS(("./program", "--multienum1=(4, 5)"))
self.assertEqual(FLAGS.multienum1, (4, 5))
class MultiEnumClassTest(parameterized.TestCase):
def test_multi_enum_class(self):
ff.DEFINE_dict(
"dict_with_multi_enum_class",
item=ff.MultiEnumClass([MyEnum.A], MyEnum, "multi enum"),
)
FLAGS(("./program",
"--dict_with_multi_enum_class.item=A",
"--dict_with_multi_enum_class.item=B",
"--dict_with_multi_enum_class.item=A",))
expected = [MyEnum.A, MyEnum.B, MyEnum.A]
self.assertEqual(FLAGS.dict_with_multi_enum_class["item"], expected)
class MultiStringTest(parameterized.TestCase):
def test_defaults_parsing(self):
ff.DEFINE_dict(
"dict_with_multistrings",
no_default=ff.MultiString(None, "no default"),
single_entry=ff.MultiString("a", "single entry"),
single_entry_list=ff.MultiString(["a"], "single entry list"),
multiple_entry_list=ff.MultiString(["a", "b"], "multiple entry list"),
)
self.assertEqual(FLAGS.dict_with_multistrings,
{"no_default": None,
"single_entry": ["a"],
"single_entry_list": ["a"],
"multiple_entry_list": ["a", "b"]})
class SerializationTest(absltest.TestCase):
def test_basic_serialization(self):
ff.DEFINE_dict(
"to_serialize",
integer_field=ff.Integer(1, "integer field"),
boolean_field=ff.Boolean(False, "boolean field"),
string_list_field=ff.StringList(["a", "b", "c"], "string list field"),
enum_class_field=ff.EnumClass(MyEnum.A, MyEnum, "my enum field"),
)
initial_dict_value = copy.deepcopy(FLAGS["to_serialize"].value)
# Parse flags, then serialize.
FLAGS(["./program",
"--to_serialize.boolean_field=True",
"--to_serialize.integer_field", "1337",
"--to_serialize.string_list_field=d,e,f",
"--to_serialize.enum_class_field=B",
])
self.assertEqual(FLAGS["to_serialize"].serialize(), _flags._EMPTY)
self.assertEqual(FLAGS["to_serialize.boolean_field"].serialize(),
"--to_serialize.boolean_field=True")
self.assertEqual(FLAGS["to_serialize.string_list_field"].serialize(),
"--to_serialize.string_list_field=d,e,f")
parsed_dict_value = copy.deepcopy(FLAGS["to_serialize"].value)
self.assertDictEqual(parsed_dict_value, {
"boolean_field": True,
"integer_field": 1337,
"string_list_field": ["d", "e", "f"],
"enum_class_field": MyEnum.B,
})
self.assertNotEqual(FLAGS["to_serialize"].value, initial_dict_value)
# test a round trip
serialized_args = [
FLAGS[name].serialize() for name in FLAGS if name.startswith(
"to_serialize.")]
FLAGS.unparse_flags() # Reset to defaults
self.assertDictEqual(FLAGS["to_serialize"].value, initial_dict_value)
FLAGS(["./program"] + serialized_args)
self.assertDictEqual(FLAGS["to_serialize"].value, parsed_dict_value)
if __name__ == "__main__":
absltest.main()
| {"/fancyflags/_flags_test.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/example_module.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/override_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_flagsaver_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_argument_parsers_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions.py": ["/fancyflags/__init__.py"]} |
50,071 | corypaik/fancyflags | refs/heads/master | /setup.py | # Copyright 2021 DeepMind Technologies Limited.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.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.
# ============================================================================
"""Install script for fancyflags."""
import imp
from setuptools import find_packages
from setuptools import setup
setup(
name='fancyflags',
version=imp.load_source('_metadata', 'fancyflags/_metadata.py').__version__,
description='A Python library for defining dictionary-valued flags.',
author='DeepMind',
license='Apache License, Version 2.0',
packages=find_packages(),
install_requires=['absl-py>=0.12.0'],
tests_require=[
'pytest',
'dataclasses ; python_version<"3.7"',
],
classifiers=[
'Programming Language :: Python',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3.8',
'Programming Language :: Python :: 3.9',
'Intended Audience :: Developers',
'Topic :: Software Development :: Libraries :: Python Modules',
'License :: OSI Approved :: Apache Software License',
'Operating System :: OS Independent',
],
)
| {"/fancyflags/_flags_test.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/example_module.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/override_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_flagsaver_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_argument_parsers_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions.py": ["/fancyflags/__init__.py"]} |
50,072 | corypaik/fancyflags | refs/heads/master | /fancyflags/_argument_parsers_test.py | # Copyright 2021 DeepMind Technologies Limited.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.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.
# ============================================================================
"""Tests for argument_parsers."""
from absl.testing import absltest
from absl.testing import parameterized
from fancyflags import _argument_parsers
class SequenceParserTest(parameterized.TestCase):
def setUp(self):
super().setUp()
self.parser = _argument_parsers.SequenceParser()
@parameterized.parameters(
([1, 2, 3],),
([],),
((),),
(["hello", "world"],),
((3.14, 2.718),),
((1, -1.0),),
)
def test_parse_input_sequence(self, input_sequence):
result = self.parser.parse(input_sequence)
self.assertEqual(result, input_sequence)
@parameterized.parameters(
(u"[1, 2, 3]", [1, 2, 3]),
("[]", []),
("()", ()),
("['hello', 'world']", ["hello", "world"]),
("(3.14, 2.718)", (3.14, 2.718)),
("(1, -1.0)", (1, -1.0),),
)
def test_parse_input_string(self, input_string, expected):
result = self.parser.parse(input_string)
self.assertEqual(result, expected)
# Check that the string-formatted expected result also matches the input
self.assertEqual("{}".format(expected), input_string)
@parameterized.parameters(
("[\"hello\", u\"world\"]", ["hello", u"world"]),
("(1,2,3)", (1, 2, 3)),
)
def test_parse_input_string_different_format(self, input_string, expected):
# The parser/ast result should also work for slightly different formatting.
result = self.parser.parse(input_string)
self.assertEqual(result, expected)
def test_parse_none(self):
result = self.parser.parse(None)
self.assertEqual(result, [])
@parameterized.parameters(
({1, 2, 3},),
(100,),
)
def test_parse_invalid_input_type(self, input_item):
with self.assertRaisesRegex(TypeError, "Unsupported type"):
self.parser.parse(input_item)
@parameterized.parameters(
("'hello world'",),
("{1: 3}",),
)
def test_parse_invalid_evaluated_type(self, input_string):
with self.assertRaisesRegex(TypeError, "evaluated as"):
self.parser.parse(input_string)
@parameterized.parameters(
# No nested anything.
([1, [2, 3]],),
([1, (2, 3)],),
((1, [2, 3]),),
((1, (2, 3)),),
# Nothing outside the listed primitive types.
([1, set()],),
)
def test_parse_invalid_entries(self, input_item):
with self.assertRaisesRegex(TypeError, "contains unsupported"):
self.parser.parse(input_item)
class MultiEnumParserTest(parameterized.TestCase):
def setUp(self):
super().setUp()
self.parser = _argument_parsers.MultiEnumParser(
["a", "a", ["a"], "b", "c", 1, [2], {
"a": "d"
}])
@parameterized.parameters(('["a"]', ["a"]),
('[["a"], "a"]', [["a"], "a"]),
('[1, "a", {"a": "d"}]', [1, "a", {"a": "d"}])
)
def test_parse_input(self, inputs, target):
self.assertEqual(self.parser.parse(inputs), target)
@parameterized.parameters(("'a'", "evaluated as a"),
(1, "Unsupported type"),
({"a"}, "Unsupported type"),
("''", "evaluated as a")
)
def test_invalid_input_type(self, input_item, regex):
with self.assertRaisesRegex(TypeError, regex):
self.parser.parse(input_item)
@parameterized.parameters("[1, 2]",
'["a", ["b"]]')
def test_out_of_enum_values(self, inputs):
with self.assertRaisesRegex(ValueError, "Argument values should be one of"):
self.parser.parse(inputs)
with self.assertRaisesRegex(ValueError, "Argument values should be one of"):
self.parser.parse(inputs)
if __name__ == "__main__":
absltest.main()
| {"/fancyflags/_flags_test.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/example_module.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/override_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_flagsaver_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_argument_parsers_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions.py": ["/fancyflags/__init__.py"]} |
50,073 | corypaik/fancyflags | refs/heads/master | /fancyflags/_definitions.py | # Copyright 2021 DeepMind Technologies Limited.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.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.
# ============================================================================
"""Functionality for defining `Item`s and dict flags."""
import collections
from absl import flags
from fancyflags import _argument_parsers
from fancyflags import _flags
# internal imports: usage_logging
SEPARATOR = "."
_NOT_A_DICT_OR_ITEM = """
DEFINE_dict only supports flat or nested dictionaries, and these must contain
`ff.Item`s or `ff.MultiItems. Found type {} in this definition.
"""
# Add this module to absl's exclusion set for determining the calling modules.
flags.disclaim_key_flags()
def DEFINE_dict(*args, **kwargs): # pylint: disable=invalid-name
"""Defines a flat or nested dictionary flag.
Usage example:
```python
import fancyflags as ff
ff.DEFINE_dict(
"image_settings",
mode=ff.String("pad", "Mode string field."),
sizes=dict(
width=ff.Integer(5, "Width."),
height=ff.Integer(7, "Height."),
scale=ff.Float(0.5, "Scale.")
)
)
This creates a flag `FLAGS.image_settings`, with a default value of
```python
{
"mode": "pad",
"sizes": {
"width": 5,
"height": 7,
"scale": 0.5,
}
}
```
Each item in the definition (e.g. ff.Integer(...)) corresponds to a flag that
can be overridden from the command line using "dot" notation. For example, the
following command overrides the `height` item in the nested dictionary defined
above:
```
python script_name.py -- --image_settings.sizes.height=10
```
Args:
*args: One or two positional arguments are expected:
1. A string containing the root name for this flag. This must be set.
2. Optionally, a `flags.FlagValues` object that will hold the Flags.
If not set, the usual global `flags.FLAGS` object will be used.
**kwargs: One or more keyword arguments, where the value is either an
`ff.Item` such as `ff.String(...)` or `ff.Integer(...)` or a dict with the
same constraints.
Returns:
A `FlagHolder` instance.
"""
if not args:
raise ValueError("Please supply one positional argument containing the "
"top-level flag name for the dict.")
if not kwargs:
raise ValueError("Please supply at least one keyword argument defining a "
"flag.""")
if len(args) > 2:
raise ValueError("Please supply at most two positional arguments, the "
"first containing the top-level flag name for the dict "
"and, optionally and unusually, a second positional "
"argument to override the flags.FlagValues instance to "
"use.")
if not isinstance(args[0], str):
raise ValueError("The first positional argument must be a string "
"containing top-level flag name for the dict. Got a {}.".
format(type(args[0]).__name__))
if len(args) == 2:
if not isinstance(args[1], flags.FlagValues):
raise ValueError("If supplying a second positional argument, this must "
"be a flags.FlagValues instance. Got a {}. If you meant "
"to define a flag, note these must be supplied as "
"keyword arguments. ".format(type(args[1]).__name__))
flag_values = args[1]
else:
flag_values = flags.FLAGS
flag_name = args[0]
shared_dict = define_flags(flag_name, kwargs, flag_values=flag_values)
# usage_logging: dict
# TODO(b/177672282): Can we persuade pytype to correctly infer the type of the
# flagholder's .value attribute?
# We register a dummy flag that returns `shared_dict` as a value.
return flags.DEFINE_flag(
_flags.DictFlag(
shared_dict,
name=flag_name,
default=shared_dict,
parser=flags.ArgumentParser(),
serializer=None,
help_string="Unused help string."),
flag_values=flag_values)
def define_flags(name, name_to_item, flag_values=flags.FLAGS):
"""Defines dot-delimited flags from a flat or nested dict of `ff.Item`s.
Args:
name: The top-level name to prepend to each flag.
name_to_item: A flat or nested dictionary, where each final value is an
`ff.Item` such as `ff.String(...)` or `ff.Integer(...)`.
flag_values: The `flags.FlagValues` instance to use. By default this is
`flags.FLAGS`. Most users will not need to override this.
Returns:
A flat or nested dictionary containing the default values in `name_to_item`.
Overriding any of the flags defined by this function will also update the
corresponding entry in the returned dictionary.
"""
# Each flag that we will define holds a reference to `shared_dict`, which is
# a flat or nested dictionary containing the default values.
shared_dict = _extract_defaults(name_to_item)
# We create flags for each leaf item (e.g. ff.Integer(...)).
# These are the flags that users will actually interact with when overriding
# flags from the command line, however they will not access directly in their
# scripts. It is also the job of these flags to update the corresponding
# values in `shared_dict`, whenever their own values change.
def recursively_define_flags(namespace, maybe_definition):
if isinstance(maybe_definition, dict):
for key, value in maybe_definition.items():
recursively_define_flags(namespace + (key,), value)
else:
maybe_definition.define(namespace, {name: shared_dict}, flag_values)
for key, value in name_to_item.items():
recursively_define_flags(namespace=(name, key), maybe_definition=value)
return shared_dict
def _extract_defaults(name_to_item):
"""Converts a flat or nested dict into a flat or nested dict of defaults."""
result = {}
for key, value in name_to_item.items():
if isinstance(value, (Item, MultiItem)):
result[key] = value.default
elif isinstance(value, dict):
result[key] = _extract_defaults(value)
else:
type_name = type(value).__name__
raise TypeError(_NOT_A_DICT_OR_ITEM.format(type_name))
return result
class Item:
"""Defines a flag for leaf items in the dictionary."""
def __init__(self, default, help_string, parser, serializer=None):
"""Initializes a new `Item`.
Args:
default: Default value of the flag that this instance will create.
help_string: Help string for the flag that this instance will create. If
`None`, then the dotted flag name will be used as the help string.
parser: A `flags.ArgumentParser` used to parse command line input.
serializer: An optional custom `flags.ArgumentSerializer`. By default, the
flag defined by this class will use an instance of the base
`flags.ArgumentSerializer`.
"""
# Flags run the following lines of parsing code during initialization.
# See Flag._set_default in absl/flags/_flag.py
# It's useful to repeat it here so that users will see any errors when the
# Item is initialized, rather than when define() is called later.
# The only minor difference is that Flag._set_default calls Flag._parse,
# which also catches and modifies the exception type.
if default is None:
self.default = default
else:
self.default = parser.parse(default)
self._help_string = help_string
self._parser = parser
if serializer is None:
self._serializer = flags.ArgumentSerializer()
else:
self._serializer = serializer
def define(self, namespace, shared_dict, flag_values):
"""Defines a flag that when parsed will update a shared dictionary.
Args:
namespace: A sequence of strings that define the name of this flag. For
example, `("foo", "bar")` will correspond to a flag named `foo.bar`.
shared_dict: A dictionary that is shared by the top level dict flag. When
the individual flag created by this method is parsed, it will also
write the parsed value into `shared_dict`. The `namespace` determines
the flat or nested key when storing the parsed value.
flag_values: The `flags.FlagValues` instance to use.
"""
name = SEPARATOR.join(namespace)
help_string = name if self._help_string is None else self._help_string
flags.DEFINE_flag(
_flags.ItemFlag(
shared_dict,
namespace,
parser=self._parser,
serializer=self._serializer,
name=name,
default=self.default,
help_string=help_string),
flag_values=flag_values)
class Boolean(Item):
def __init__(self, default, help_string=None):
super().__init__(default, help_string, flags.BooleanParser())
# TODO(b/177673597) Better document the different enum class options and
# possibly recommend some over others.
class Enum(Item):
def __init__(self,
default,
enum_values,
help_string=None,
case_sensitive=True):
parser = flags.EnumParser(enum_values, case_sensitive)
super().__init__(default, help_string, parser)
class EnumClass(Item):
"""Matches behaviour of flags.DEFINE_enum_class."""
def __init__(self, default, enum_class, help_string=None):
parser = flags.EnumClassParser(enum_class)
super().__init__(
default, help_string, parser,
flags.EnumClassSerializer(lowercase=False))
class Float(Item):
def __init__(self, default, help_string=None):
super().__init__(default, help_string, flags.FloatParser())
class Integer(Item):
def __init__(self, default, help_string=None):
super().__init__(default, help_string, flags.IntegerParser())
class Sequence(Item):
r"""Defines a flag for a list or tuple of simple numeric types or strings.
Here is an example of overriding a Sequence flag within a dict-flag named
"settings" from the command line, with a list of values.
```
--settings.sequence=[1,2,3]
```
To include spaces, either quote the entire literal, or escape spaces as:
```
--settings.sequence="[1, 2, 3]"
--settings.sequence=[1,\ 2,\ 3]
```
"""
def __init__(self, default, help_string=None):
super().__init__(default, help_string, _argument_parsers.SequenceParser())
class String(Item):
def __init__(self, default, help_string=None):
super().__init__(default, help_string, flags.ArgumentParser())
class StringList(Item):
"""A flag that implements the same behavior as absl.flags.DEFINE_list.
Can be overwritten as --my_flag="a,list,of,commaseparated,strings"
"""
def __init__(self, default, help_string=None):
serializer = flags.CsvListSerializer(",")
super().__init__(default, help_string, flags.ListParser(), serializer)
# MultiFlag-related functionality.
class MultiItem:
"""Class for items that can appear multiple times on the command line.
See Item class for more details on methods and usage.
"""
def __init__(self,
default,
help_string,
parser,
serializer=None):
if default is None:
self.default = default
else:
if (isinstance(default, collections.abc.Iterable) and
not isinstance(default, (str, bytes))):
# Convert all non-string iterables to lists.
default = list(default)
if not isinstance(default, list):
# Turn single items into single-value lists.
default = [default]
# Ensure each individual value is well-formed.
self.default = [parser.parse(item) for item in default]
self._help_string = help_string
self._parser = parser
if serializer is None:
self._serializer = flags.ArgumentSerializer()
else:
self._serializer = serializer
def define(self, namespace, shared_dict, flag_values):
name = SEPARATOR.join(namespace)
help_string = name if self._help_string is None else self._help_string
flags.DEFINE_flag(
_flags.MultiItemFlag(
shared_dict,
namespace,
parser=self._parser,
serializer=self._serializer,
name=name,
default=self.default,
help_string=help_string),
flag_values=flag_values)
class MultiEnum(Item):
"""Defines a flag for lists of values of any type, matched to enum_values."""
def __init__(self, default, enum_values, help_string=None):
parser = _argument_parsers.MultiEnumParser(enum_values)
serializer = flags.ArgumentSerializer()
_ = parser.parse(enum_values)
super().__init__(default, help_string, parser, serializer)
class MultiEnumClass(MultiItem):
"""Matches behaviour of flags.DEFINE_multi_enum_class."""
def __init__(self, default, enum_class, help_string=None):
parser = flags.EnumClassParser(enum_class)
serializer = flags.EnumClassListSerializer(",", lowercase=False)
super().__init__(default, help_string, parser, serializer)
class MultiString(MultiItem):
"""Matches behaviour of flags.DEFINE_multi_string."""
def __init__(self, default, help_string=None):
parser = flags.ArgumentParser()
serializer = flags.ArgumentSerializer()
super().__init__(default, help_string, parser, serializer)
# Misc DEFINE_*s.
def DEFINE_multi_enum( # pylint: disable=invalid-name,redefined-builtin
name, default, enum_values, help, flag_values=flags.FLAGS, **args):
"""Defines flag for MultiEnum."""
parser = _argument_parsers.MultiEnumParser(enum_values)
serializer = flags.ArgumentSerializer()
# usage_logging: multi_enum
flags.DEFINE(parser, name, default, help, flag_values, serializer, **args)
def DEFINE_sequence( # pylint: disable=invalid-name,redefined-builtin
name, default, help, flag_values=flags.FLAGS, **args):
"""Defines a flag for a list or tuple of simple types. See `Sequence` docs."""
parser = _argument_parsers.SequenceParser()
serializer = flags.ArgumentSerializer()
# usage_logging: sequence
flags.DEFINE(parser, name, default, help, flag_values, serializer, **args)
| {"/fancyflags/_flags_test.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/example_module.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_define_auto.py": ["/fancyflags/__init__.py"], "/fancyflags/examples/override_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_auto_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_flagsaver_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_argument_parsers_test.py": ["/fancyflags/__init__.py"], "/fancyflags/_definitions.py": ["/fancyflags/__init__.py"]} |
50,077 | ShahadCS/PyTorch-YOLOv3_Text_Detection | refs/heads/master | /utils/datasets.py | import glob
import random
import os
import sys
import numpy as np
from PIL import Image
import torch
import torch.nn.functional as F
from utils.augmentations import horisontal_flip
from torch.utils.data import Dataset
import torchvision.transforms as transforms
def pad_to_square(img, pad_value):
c, h, w = img.shape
dim_diff = np.abs(h - w)
# (upper / left) padding and (lower / right) padding
pad1, pad2 = dim_diff // 2, dim_diff - dim_diff // 2
# Determine padding
pad = (0, 0, pad1, pad2) if h <= w else (pad1, pad2, 0, 0)
pad = torch.from_numpy(np.array(pad))
# Add padding
img = F.pad(img, pad, "constant", value=pad_value)
return img, pad
def resize(image, size):
image = F.interpolate(image.unsqueeze(0), size=size, mode="nearest").squeeze(0)
return image
def random_resize(images, min_size=288, max_size=448):
new_size = random.sample(list(range(min_size, max_size + 1, 32)), 1)[0]
images = F.interpolate(images, size=new_size, mode="nearest")
return images
class ImageFolder(Dataset):
def __init__(self, folder_path, img_size=416):
self.files = sorted(glob.glob("%s/*.*" % folder_path))
self.img_size = img_size
def __getitem__(self, index):
img_path = self.files[index % len(self.files)]
# Extract image as PyTorch tensor
img = transforms.ToTensor()(Image.open(img_path))
# Pad to square resolution
img, _ = pad_to_square(img, 0)
# Resize
img = resize(img, self.img_size)
return img_path, img
def __len__(self):
return len(self.files)
class ListDataset(Dataset):
def __init__(self, image_path, label_path, img_size=416, augment=True, multiscale=False, normalized_labels=False): #Augmentation removed and normalized labels removed, img_size changed from 416 to 200
img_list = []
lbl_list = []
for i in range(len(os.listdir(image_path))):
img_f_name = "img_{}.jpg".format(i+1)
lbl_f_name = "gt_img_{}.txt".format(i+1)
img_list.append(img_f_name)
lbl_list.append(lbl_f_name)
self.img_files = img_list
self.label_files = lbl_list
self.img_path = image_path
self.label_path = label_path
#
#with open(list_path, "r") as file:
# self.img_files = file.readlines()
#self.label_files = [
# path.replace("images", "labels").replace(".png", ".txt").replace(".jpg", ".txt")
# for path in self.img_files
#]
self.img_size = img_size
self.max_objects = 100
self.augment = augment
self.multiscale = multiscale
self.normalized_labels = normalized_labels
self.min_size = self.img_size - 5 * 32
self.max_size = self.img_size + 3 * 32
self.batch_count = 0
def __getitem__(self, index):
# ---------
# Image
# ---------
img_path = self.img_files[index % len(self.img_files)]#.rstrip()
# link path and file names
img_path = self.img_path+img_path
""" ###################### """
# Extract image as PyTorch tensor
img = transforms.ToTensor()(Image.open(img_path).convert('RGB'))
# Handle images with less than three channels
if len(img.shape) != 3:
img = img.unsqueeze(0)
img = img.expand((3, img.shape[1:]))
#print("----------image testing for index {}---------------".format(index))
#print("label path: ", img_path)
_, h, w = img.shape
#print("original image shape ", img.shape)
#print(h,w)
h_factor, w_factor = (h, w) if self.normalized_labels else (1, 1)
# Pad to square resolution
img, pad = pad_to_square(img, 0)
_, padded_h, padded_w = img.shape
#print("padded img shape ", img.shape)
#print(padded_h, padded_w)
# ---------
# Label
# ---------
lbl_path = self.label_files[index % len(self.img_files)]#.rstrip()
#print("labels index ", index % len(self.img_files))
lbl_path = self.label_path+lbl_path
targets = None
if os.path.exists(lbl_path):
#print(lbl_path)
#print(img_path)
imported_txt = torch.from_numpy(np.loadtxt(lbl_path, delimiter=",", usecols = (0,1,2,3,4,5,6,7), encoding = "utf-8-sig", dtype = 'float64').reshape(-1, 8))
#print("------------------Image Label Testing for index {}--------------------------------".format(index))
#print("label path: ", lbl_path)
#print("imported text")
#print(imported_txt)
boxes = torch.zeros((len(imported_txt), 5))
for i in range(len(imported_txt)):
x_max = max(imported_txt[i][0],imported_txt[i][2],imported_txt[i][4],imported_txt[i][6])
x_min = min(imported_txt[i][0],imported_txt[i][2],imported_txt[i][4],imported_txt[i][6])
y_max = max(imported_txt[i][1],imported_txt[i][3],imported_txt[i][5],imported_txt[i][7])
y_min = min(imported_txt[i][1],imported_txt[i][3],imported_txt[i][5],imported_txt[i][7])
height = y_max - y_min
width = x_max - x_min
boxes[i][1] = x_min # for top left x axis
boxes[i][2] = y_min # for top left y axis
boxes[i][3] = width
boxes[i][4] = height
#print("boxes")
#print(boxes)
center_x = w_factor * (boxes[:, 1] + boxes[:, 3] / 2)
center_y = h_factor * (boxes[:, 2] + boxes[:, 4] / 2)
#print("unpadded center x")
#print(center_x)
#print("unpadded center y")
#print(center_y)
#print("padding")
#print(pad)
#width = boxes[:,3]
#height = boxes[:,4]
#print(type(center_x))
#print(type(pad[2]))
center_x=torch.add(center_x,float(pad[0]))
center_y=torch.add(center_y,float(pad[2]))
# center_x = center_x + pad[0]
# center_y = center_y + pad[2]
boxes[:, 1] = center_x / padded_w
boxes[:, 2] = center_y / padded_h
boxes[:, 3] *= w_factor / padded_w
boxes[:, 4] *= h_factor / padded_h
#print(boxes)
#for i in range(0,boxes.shape[0]):
# if(boxes[i,1]>1):
# print("w")
# print(w_factor)
# print(boxes[i,1])
# print( padded_w)
# print(center_x[i], boxes[i,3])
# exit()
#for j in range(0,boxes.shape[0]):
# if(boxes[j,2]>1):
# print("h")
# print(boxes[j,2])
# print(padded_h)
# print(center_y[i], boxes[i,4])
# exit()
#print("-----------------img label testing end------------------------")
targets = torch.zeros((len(boxes), 6))
targets[:, 1:] = boxes
# Apply augmentations
if self.augment:
if np.random.random() < 0.5:
img, targets = horisontal_flip(img, targets)
return img_path, img, targets
def collate_fn(self, batch):
paths, imgs, targets = list(zip(*batch))
# Remove empty placeholder targets
targets = [boxes for boxes in targets if boxes is not None]
# Add sample index to targets
for i, boxes in enumerate(targets):
boxes[:, 0] = i
targets = torch.cat(targets, 0)
# Selects new image size every tenth batch
if self.multiscale and self.batch_count % 10 == 0:
self.img_size = random.choice(range(self.min_size, self.max_size + 1, 32))
# Resize images to input shape
imgs = torch.stack([resize(img, self.img_size) for img in imgs])
self.batch_count += 1
return paths, imgs, targets
def __len__(self):
return len(self.img_files)
| {"/train.py": ["/utils/datasets.py"]} |
50,078 | ShahadCS/PyTorch-YOLOv3_Text_Detection | refs/heads/master | /train.py | from __future__ import division
from models import *
#from utils.logger import *
from utils.utils import *
from utils.datasets import *
from utils.parse_config import *
import test
import visdom_plots as vplt
#from terminaltables import AsciiTable
import os
import sys
import time
import datetime
import argparse
import torch
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision import transforms
from torch.autograd import Variable
import torch.optim as optim
import numpy as np
from visdom import Visdom
from collections import defaultdict
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--epochs", type=int, default=100, help="number of epochs")
parser.add_argument("--batch_size", type=int, default=2, help="size of each image batch") # changed to 1 from 8
parser.add_argument("--gradient_accumulations", type=int, default=2, help="number of gradient accums before step")
parser.add_argument("--model_def", type=str, default="config/yolov3-custom.cfg", help="path to model definition file")
parser.add_argument("--data_config", type=str, default="config/detext.data", help="path to data config file")
parser.add_argument("--pretrained_weights", type=str, help="if specified starts from checkpoint model")
parser.add_argument("--n_cpu", type=int, default=6, help="number of cpu threads to use during batch generation") # changed to 6 from 8
parser.add_argument("--img_size", type=int, default=416, help="size of each image dimension") #changed to 50 from 416
parser.add_argument("--checkpoint_interval", type=int, default=1, help="interval between saving model weights")
parser.add_argument("--evaluation_interval", type=int, default=1, help="interval evaluations on validation set")
parser.add_argument("--compute_map", default=False, help="if True computes mAP every tenth batch")
parser.add_argument("--multiscale_training", default=False, help="allow for multi-scale training") # changed to false
parser.add_argument("--log", default=datetime.datetime.now().strftime("%d%b%Y_%H%M"), help="set log folder name and visdom plots set environment name") # changed to false
opt = parser.parse_args()
print(opt)
log_name=opt.log
#logger = Logger("logs")
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
os.makedirs("output", exist_ok=True)
os.makedirs("checkpoints", exist_ok=True)
#create directory to store logs
log_dir = "logs/log_{}".format(log_name)
os.makedirs(log_dir, exist_ok=True)
# initialiase visdom plotting and required variables
plots = vplt.VisdomLinePlotter(log_name)
#use to delete environement plots.viz.delete_env("13Jul2019_0946")
plotting_batch = 0
# Get data configuration
data_config = parse_data_config(opt.data_config)
train_path = data_config["train"]
train_label_path = data_config["train_label"]
valid_path = data_config["valid"]
valid_label_path = data_config["valid_label"]
class_names = load_classes(data_config["names"])
#store the arguments
with open(log_dir+"/parameters.txt", 'w+') as f:
f.write(str(opt))
#f= open("logs/Log_{}.txt".format(log_name),"w+")
#f.write(opt)
#f.close(())
# Initiate model
model = Darknet(opt.model_def).to(device)
model.apply(weights_init_normal)
# If specified we start from checkpoint
if opt.pretrained_weights:
if opt.pretrained_weights.endswith(".pth"):
model.load_state_dict(torch.load(opt.pretrained_weights))
else:
model.load_darknet_weights(opt.pretrained_weights)
# Get dataloader
dataset = ListDataset(train_path, train_label_path, img_size=opt.img_size, augment=True, multiscale=opt.multiscale_training)# augment = changed to false
dataloader = torch.utils.data.DataLoader(
dataset,
batch_size=opt.batch_size,
shuffle=True,
num_workers=opt.n_cpu,
pin_memory=True,
collate_fn=dataset.collate_fn,
)
optimizer = torch.optim.Adam(model.parameters())
metrics = [
"grid_size",
"loss",
"x",
"y",
"w",
"h",
"conf",
"cls",
"cls_acc",
"recall50",
"recall75",
"precision",
"conf_obj",
"conf_noobj",
]
for epoch in range(opt.epochs):
model.train()
start_time = time.time()
batch_log = []
for batch_i, (_, imgs, targets) in enumerate(dataloader):
#print("batch"+str(batch_i))
#print(targets)
batches_done = len(dataloader) * epoch + batch_i
imgs = Variable(imgs.to(device))
targets = Variable(targets.to(device), requires_grad=False)
loss, outputs = model(imgs, targets)
loss.backward()
if batches_done % opt.gradient_accumulations:
# Accumulates gradient before each step
optimizer.step()
optimizer.zero_grad()
# ----------------
# Log progress
# ----------------
log_str = "\n---- [Epoch %d/%d, Batch %d/%d] ----\n" % (epoch, opt.epochs, batch_i, len(dataloader))
log_str += "| ------------|-------------|-------------|------------ |\n"
metric_table = [["Metrics", *[f"YOLO Layer {i}" for i in range(len(model.yolo_layers))]]]
save_log = [["Epoch", "Batch", "Metrics", *[f"YOLO Layer {i}" for i in range(len(model.yolo_layers))]]]
txt_log = []
txt_log += [("epoch", epoch)]
txt_log += [("batch", batch_i)]
# Log metrics at each YOLO layer
for i, metric in enumerate(metrics):
formats = {m: "%.6f" for m in metrics}
formats["grid_size"] = "%2d"
formats["cls_acc"] = "%.2f%%"
row_metrics = [formats[metric] % yolo.metrics.get(metric, 0) for yolo in model.yolo_layers]
metric_table += [[metric, *row_metrics]]
save_log += [[epoch, batch_i, metric, *row_metrics]]
# Tensorboard logging
#tensorboard_log = []
#for j, yolo in enumerate(model.yolo_layers):
# for name, metric in yolo.metrics.items():
# if name != "grid_size":
# tensorboard_log += [(f"{name}_{j+1}", metric)]
#txt_log += [(f"{name}_{j+1}", metric)]
#tensorboard_log += [("loss", loss.item())]
for indx, yolo in enumerate(model.yolo_layers):
for name, metric in yolo.metrics.items():
if name != "grid_size":
txt_log += [(f"{name}_{indx+1}", metric)]
#plots.plot(f"{name}", f"{name}_YOLO_layer_{indx+1}", f"{name}_YOLO_layer_{indx+1}", plotting_batch, metric)
txt_log += [("loss", loss.item())]
batch_log += txt_log
with open(log_dir+"/batch_data.txt", 'a') as f:
f.write(str(txt_log)+'\n')
txt_log = []
for i, val in enumerate(metric_table):
valj = "| "
if i == 1:
valj += "------------|-------------|-------------|------------ |\n| "
for j, val2 in enumerate(val):
if len(val[j]) <= 12:
for k in range(0,12-len(val[j])):
val[j] += " "
val[j] += "| "
valj += val[j]
valj +="\n"
log_str += valj
log_str += "| ------------|-------------|-------------|------------ |\n"
# log_str += metric_table
#print(metric_table)
#log_str += metric_table
log_str += f"\nTotal loss {loss.item()}"
#np.savetxt("logs/)
# Determine approximate time left for epoch
epoch_batches_left = len(dataloader) - (batch_i + 1)
time_left = datetime.timedelta(seconds=epoch_batches_left * (time.time() - start_time) / (batch_i + 1))
log_str += f"\n---- ETA {time_left}"
print(log_str)
model.seen += imgs.size(0)
# ====== plotting loss of the class per batch==================
plots.plot("Loss Batch", "Train", "Training Batch Loss", plotting_batch, loss.item(), "Batches")
plotting_batch += 1
#========== plotting mean batch metrics for the epoch ================
if epoch % opt.evaluation_interval == 0:
batch_stats = defaultdict(list)
for i, name in enumerate(batch_log):
batch_stats[name[0]].append(name[1])
for k in range(3):
plots.plot("Loss_YOLO", "Loss_YOLO_{}".format(k+1), "Training Loss at YOLO Layers", epoch, np.mean(batch_stats["loss_{}".format(k+1)]), "Epochs")
plots.plot("x_YOLO", "x_YOLO_{}".format(k+1), "Training x at YOLO Layers", epoch, np.mean(batch_stats["x_{}".format(k+1)]), "Epochs")
plots.plot("y_YOLO", "y_YOLO_{}".format(k+1), "Training y at YOLO Layers", epoch, np.mean(batch_stats["y_{}".format(k+1)]), "Epochs")
plots.plot("w_YOLO", "w_YOLO_{}".format(k+1), "Training w at YOLO Layers", epoch, np.mean(batch_stats["w_{}".format(k+1)]), "Epochs")
plots.plot("h_YOLO", "h_YOLO_{}".format(k+1), "Training h at YOLO Layers", epoch, np.mean(batch_stats["h_{}".format(k+1)]), "Epochs")
plots.plot("conf_YOLO", "conf_YOLO_{}".format(k+1), "Training conf at YOLO Layers", epoch, np.mean(batch_stats["conf_{}".format(k+1)]), "Epochs")
plots.plot("cls_YOLO", "cls_YOLO_{}".format(k+1), "Training cls at YOLO Layers", epoch, np.mean(batch_stats["cls_{}".format(k+1)]), "Epochs")
plots.plot("cls_acc_YOLO", "cls_acc_YOLO_{}".format(k+1), "Training cls_acc at YOLO Layers", epoch, np.mean(batch_stats["cls_acc_{}".format(k+1)]), "Epochs")
plots.plot("recall50_YOLO", "recall50_YOLO_{}".format(k+1), "Training recall50 at YOLO Layers", epoch, np.mean(batch_stats["recall50_{}".format(k+1)]), "Epochs")
plots.plot("precision_YOLO", "precision_YOLO_{}".format(k+1), "Training precision at YOLO Layers", epoch, np.mean(batch_stats["precision_{}".format(k+1)]), "Epochs")
plots.plot("conf_obj_YOLO", "conf_obj_YOLO_{}".format(k+1), "Training conf_obj at YOLO Layers", epoch, np.mean(batch_stats["conf_obj_{}".format(k+1)]), "Epochs")
plots.plot("conf_noobj_YOLO", "conf_noobj_YOLO_{}".format(k+1), "Training conf_noobj at YOLO Layers", epoch, np.mean(batch_stats["conf_noobj_{}".format(k+1)]), "Epochs")
plots.plot("epoch_loss","Loss", "Loss", epoch, np.mean(batch_stats["loss"]), "Epochs")
if epoch == 0:
plots.plot("mAP_Epoch", "Mean AP", "Mean AP", epoch, 0, "Epochs")
#========= evaluation ==================
if epoch % opt.evaluation_interval == 0 and epoch != 0:
print("\n---- Evaluating Model ----")
# Evaluate the model on the validation set
precision, recall, AP, f1, ap_class = test.evaluate(
model,
im_path=valid_path,
im_gt_path=valid_label_path,
iou_thres=0.5,
conf_thres=0.5, #changed from 0.5 to 0.2
nms_thres=0.5, #changed from 0.5 to 0.2
img_size=opt.img_size,
batch_size=opt.batch_size,
)
evaluation_metrics = [
("val_precision", precision.mean()),
("val_recall", recall.mean()),
("val_mAP", AP.mean()),
("val_f1", f1.mean()),
]
#logger.list_of_scalars_summary(evaluation_metrics, epoch)
# Print class APs and mAP
ap_table = [["Index", "Class Name", "AP"]]
txt_log_epoch = []
for i, c in enumerate(ap_class):
ap_table += [[c, class_names[c], "%.5f" % AP[i]]]
txt_log_epoch += (("epoch", epoch), ("class_no", c),("class_name", class_names[c]),("AP", "%.5f" % AP[i]))
with open(log_dir+"/epoch_data.txt", 'a') as f:
f.write(str(txt_log_epoch)+'\n')
txt_log_epoch = []
epoch_log_str = "| ------------|-------------|------------ |\n"
for j, val in enumerate(ap_table):
valk = "| "
if j == 1:
valk += "------------|-------------|------------ |\n| "
for k, val2 in enumerate(val):
if len(str(val[k])) <= 12:
for m in range(0,12-len(str(val[k]))):
val[k] = str(val[k])
val[k] += " "
val[k] += "| "
valk += val[k]
valk +="\n"
epoch_log_str += valk
epoch_log_str += "| ------------|-------------|------------ |\n"
print(epoch_log_str)
print(f"---- mAP {AP.mean()}")
#======= plotting mean AP for the epoch ============
plots.plot("mAP_Epoch", "Mean AP", "Mean AP", epoch, AP.mean(), "Epochs")
plots.plot("Recall_Epoch", "Recall", "Recall", epoch, recall.mean(), "Epochs")
plots.plot("Precision_Epoch", "Precision", "Precision", epoch, precision.mean(), "Epochs")
plots.plot("f1_Epoch", "f1 Measure", "f1 Measure", epoch, f1.mean(), "Epochs")
if epoch % opt.checkpoint_interval == 0:
torch.save(model.state_dict(), f"checkpoints/yolov3_ckpt_%d.pth" % epoch)
| {"/train.py": ["/utils/datasets.py"]} |
50,084 | KarstenCollins/SeniorCapstone | refs/heads/master | /SubmitData/filters.py | from django.forms.widgets import Widget
import django_filters
from django_filters import DateFilter
from django_filters.filters import DateFromToRangeFilter, DateRangeFilter
from .models import Post
from django import forms
from django.forms import DateInput
class BillFilter(django_filters.FilterSet):
date_entered = DateFilter(field_name="date_entered", widget=DateInput(attrs={'type': 'date'}))
class Meta:
model = Post
fields = {
'title': ['icontains'],
'company_name': ['icontains'],
'payment_method': ['icontains'],
'account_number' : ['icontains'],
}
class SummariesFilter(django_filters.FilterSet):
due_date = DateFilter(field_name="due_date", widget=DateInput(attrs={'type': 'date'}))
start_date = django_filters.DateFilter(field_name="due_date", lookup_expr='gte', widget=DateInput(attrs={'type': 'date'}))
end_date = DateFilter(field_name="due_date", lookup_expr='lte', widget=DateInput(attrs={'type': 'date'}))
#due_date = DateRangeFilter(widget=django_filters.widgets.RangeWidget(attrs={'type':'datetime-local'}))
#date_between = django_filters.DateFromToRangeFilter(label='Date range is in between')
class Meta:
model = Post
fields = {'company_name' : ['icontains'],
}
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,085 | KarstenCollins/SeniorCapstone | refs/heads/master | /CompanyInformation/forms.py | from django import forms
from django.contrib.auth.models import User
from .models import Company
class CompanyCreateForm(forms.ModelForm):
class Meta:
model = Company
fields = ['company_name', 'phone_number', 'address', 'city', 'state', 'zip', 'website']
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,086 | KarstenCollins/SeniorCapstone | refs/heads/master | /SubmitData/migrations/0002_auto_20210411_0954.py | # Generated by Django 3.1.7 on 2021-04-11 16:54
import datetime
from django.db import migrations, models
import django.utils.timezone
class Migration(migrations.Migration):
dependencies = [
('SubmitData', '0001_initial'),
]
operations = [
migrations.RenameField(
model_name='post',
old_name='date_posted',
new_name='date_entered',
),
migrations.RemoveField(
model_name='post',
name='content',
),
migrations.AddField(
model_name='post',
name='account_number',
field=models.CharField(default='Default', max_length=255),
),
migrations.AddField(
model_name='post',
name='company_name',
field=models.CharField(default='Default', max_length=255),
),
migrations.AddField(
model_name='post',
name='due_date',
field=models.DateField(default=datetime.date.today),
),
migrations.AddField(
model_name='post',
name='statement_date',
field=models.DateField(default=django.utils.timezone.now),
),
migrations.AlterField(
model_name='post',
name='title',
field=models.CharField(max_length=255),
),
]
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,087 | KarstenCollins/SeniorCapstone | refs/heads/master | /IncomeInformation/filters.py | from django.forms.widgets import Widget
from django_filters.filters import DateFromToRangeFilter, DateRangeFilter
import django_filters
from django_filters import DateFilter
from django.forms import DateInput
from .models import Income
class IncomeFilter(django_filters.FilterSet):
greater_than = DateFilter(field_name="date_received", lookup_expr='gte', widget=DateInput(attrs={'type': 'date'}))
less_than = DateFilter(field_name="date_received", lookup_expr='lte', widget=DateInput(attrs={'type': 'date'}))
class Meta:
model = Income
fields = {
'source_name': ['icontains'],
}
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,088 | KarstenCollins/SeniorCapstone | refs/heads/master | /IncomeInformation/forms.py | from django import forms
from django.contrib.auth.models import User
from django.forms import ModelForm
from django.forms import widgets
from django.forms.widgets import Widget
from .models import Income
class IncomeCreateForm(forms.ModelForm):
class Meta:
model = Income
fields = ['source_name', 'amount', 'date_received']
class DateInput(forms.DateInput):
input_type='date'
class IncomeForm(ModelForm):
class Meta:
model = Income
fields = ['source_name', 'amount', 'date_received']
widgets = {
'date_received' : DateInput(),
}
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,089 | KarstenCollins/SeniorCapstone | refs/heads/master | /SubmitData/apps.py | from django.apps import AppConfig
class SubmitdataConfig(AppConfig):
name = 'SubmitData'
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,090 | KarstenCollins/SeniorCapstone | refs/heads/master | /SubmitData/models.py | from django.db import models
from django.utils import timezone
import datetime
from django.contrib.auth.models import User
from djmoney.models.fields import MoneyField
from django.urls import reverse
#change fields here and then migrate when you put in a real db for Billable
class Post(models.Model):
title = models.CharField(max_length=255)
company_name = models.CharField(max_length=255, default="")
account_number = models.CharField(max_length=255, default="")
statement_date = models.DateField(default=datetime.date.today)
due_date = models.DateField(default=datetime.date.today)
date_entered = models.DateField(default=datetime.date.today)
amount = MoneyField(max_digits=14, decimal_places=2, default_currency='USD')
is_paid = models.BooleanField(default=0)
payment_method = models.CharField(max_length=50, default="")
author = models.ForeignKey(User, on_delete=models.CASCADE) #this is where the rel. is. Foreign key is the user
previous_balance = models.IntegerField(blank=True, default='0')
minimum_payment = models.IntegerField(blank=True, default='0')
payments = models.IntegerField(blank=True, default='0')
credit = models.IntegerField(blank=True, default='0')
adjustment = models.IntegerField(blank=True, default='0')
late_fees = models.IntegerField(blank=True, default='0')
interest_charges = models.IntegerField(blank=True, default='0')
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse('data-detail', kwargs={'pk': self.pk})
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,091 | KarstenCollins/SeniorCapstone | refs/heads/master | /IncomeInformation/models.py | from django.db import models
from django.contrib.auth.models import User
from django.urls import reverse
from djmoney.models.fields import MoneyField
import datetime
# Create your models here.
class Income(models.Model):
user = models.ForeignKey(User, on_delete=models.CASCADE, null=True, default="")
source_name = models.CharField( max_length=100)
amount = MoneyField(max_digits=14, decimal_places=2, default_currency='USD')
date_received = models.DateField(default=datetime.date.today)
def __str__(self):
return self.source_name
def get_absolute_url(self):
return reverse('view-incomes')
#kwargs={'pk': self.pk}
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,092 | KarstenCollins/SeniorCapstone | refs/heads/master | /SubmitData/views.py | import csv, io
from django.shortcuts import render
from django.db.models import Q
import datetime
from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin
from django.http import HttpResponse
from django.views.generic import (
ListView,
DetailView,
CreateView,
UpdateView,
DeleteView,
)
import django_filters
from django_filters import DateFilter
from django_filters.filters import DateFromToRangeFilter, DateRangeFilter
from .models import Post
from .filters import BillFilter, SummariesFilter
from .forms import PostForm
#go into home template when you need to change the fields of the db
def home(request):
myFilter = BillFilter()
context = {
'posts': Post.objects.all(),
}
return render(request, 'SubmitData/home.html', context)
class PostListView(LoginRequiredMixin, ListView):
model = Post
template_name = 'SubmitData/home.html'
context_object_name = 'posts'
#ordering = ['-date_entered']
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['filter'] = BillFilter(self.request.GET, queryset=self.get_queryset())
return context
def get_queryset(self):#only show logged in users' data
#return self.model.objects.all().filter(author=self.request.user, is_paid=True)
return self.model.objects.all().filter(author=self.request.user).order_by('-due_date')
class PostDetailView(LoginRequiredMixin, UserPassesTestMixin, DetailView):
model = Post
def test_func(self):
post = self.get_object()
if self.request.user == post.author:
return True
return False
#CreateView handles all sending to db. It takes from the Post model and the fields are what is shown
class PostCreateView(LoginRequiredMixin, CreateView):
model = Post
#fields = ['title', 'company_name', 'account_number', 'statement_date', 'due_date', 'amount', 'payment_method',
#'is_paid', 'payment_method', 'is_paid', 'previous_balance', 'minimum_payment', 'payments', 'adjustment',
#'credit', 'late_fees', 'interest_charges']
form_class = PostForm
def form_valid(self, form):
form.instance.author = self.request.user #sets author to logged in user
return super().form_valid(form)
class PostUpdateView(LoginRequiredMixin, UserPassesTestMixin, UpdateView):
model = Post
fields = ['title', 'company_name', 'account_number', 'statement_date', 'due_date', 'amount', 'payment_method',
'is_paid', 'payment_method', 'is_paid', 'previous_balance','minimum_payment', 'payments', 'adjustment',
'credit', 'late_fees', 'interest_charges']
def form_valid(self, form):
form.instance.author = self.request.user #sets author to logged in user
return super().form_valid(form)
#the function that UserPassesTestMixin uses to stop them from updating posts that are not theirs
def test_func(self):
post = self.get_object()
if self.request.user == post.author:
return True
return False
class PostDeleteView(LoginRequiredMixin, UserPassesTestMixin, DeleteView):
model = Post
success_url = '/' #home page redirect when finished
def test_func(self):
post = self.get_object()
if self.request.user == post.author:
return True
return False
class IsPaidView(LoginRequiredMixin, ListView):
model = Post
template_name = 'SubmitData/not_paid.html'
context_object_name = 'posts'
ordering = ['-date_entered']
def get_queryset(self):#only show logged in users' data
#return self.model.objects.all().filter(Q(author=self.request.user, due_date__gte=datetime.date.today(), is_paid=False) | Q(author=self.request.user, is_paid=False)) #is_paid=False,
return self.model.objects.all().filter(Q(author=self.request.user, due_date__gte=datetime.date.today(), is_paid=False)| Q(author=self.request.user, is_paid=False)) #| Q(author=self.request.user, is_paid=False))
class YearlyMonthlySummaryView(LoginRequiredMixin, ListView):
model = Post
template_name = 'SubmitData/summaries.html'
context_object_name = 'posts'
ordering = ['-due_date']
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['summary'] = SummariesFilter(self.request.GET, queryset=self.get_queryset())
return context
def BillStatement(request):
return render(request, 'SubmitData/billstatement.html', {'title':'About'})
def BillExport(request):
items = Post.objects.all().filter(author=request.user)
#export_user = Post.objects.filter(author=request.user)
response = HttpResponse(content_type='text/csv')
response['Content-Disposition'] = 'attachment; filename="billable_bill_data.csv"'
writer = csv.writer(response, delimiter=',')
writer.writerow(['title', 'company_name', 'account_number', 'statement_date', 'due_date', 'date_entered',
'amount', 'is_paid', 'payment_method', 'previous_balance', 'minimum_payment', 'payments', 'credit', 'adjustment',
'late_fees', 'interest_charges'])
for obj in items:
writer.writerow([obj.title, obj.company_name, obj.account_number, obj.statement_date, obj.due_date, obj.date_entered,
obj.amount, obj.is_paid, obj.payment_method, obj.previous_balance, obj.minimum_payment, obj.payments, obj.credit, obj.adjustment,
obj.late_fees, obj.interest_charges])
return response | {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,093 | KarstenCollins/SeniorCapstone | refs/heads/master | /IncomeInformation/admin.py | from django.contrib import admin
from .models import Income
admin.site.register(Income)
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,094 | KarstenCollins/SeniorCapstone | refs/heads/master | /SubmitData/migrations/0006_auto_20210411_1504.py | # Generated by Django 3.1.7 on 2021-04-11 22:04
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('SubmitData', '0005_post_is_paid'),
]
operations = [
migrations.AlterField(
model_name='post',
name='is_paid',
field=models.BooleanField(default=0),
),
]
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,095 | KarstenCollins/SeniorCapstone | refs/heads/master | /CompanyInformation/views.py | from django.shortcuts import render, redirect
from django.contrib.auth.forms import UserCreationForm
from .forms import CompanyCreateForm
from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin
from django.views.generic import ListView, DetailView, CreateView, DeleteView, UpdateView
from django.contrib import messages
from .models import Company
#from .filters import CompanyFilter
class CompanyCreateView(LoginRequiredMixin, CreateView):
model = Company
fields = ['company_name', 'phone_number', 'address', 'city', 'state', 'zip', 'website']
context_object_name = 'company'
def form_valid(self, form):
form.instance.user = self.request.user #sets author to logged in user
return super().form_valid(form)
class CompanyListView(LoginRequiredMixin, ListView):
model = Company
template_name = 'CompanyInformation/company_display.html'
context_object_name = 'companys'
def get_queryset(self): #only show logged in users' data
return self.model.objects.all().filter(user=self.request.user)
class CompanyUpdateView(LoginRequiredMixin, UserPassesTestMixin, UpdateView):
model = Company
fields = ['company_name', 'phone_number', 'address', 'city', 'state', 'zip', 'website']
context_object_name = 'companys'
def form_valid(self, form):
form.instance.user = self.request.user #sets author to logged in user
return super().form_valid(form)
def test_func(self):
company = self.get_object()
if self.request.user == company.user:
return True
return False
class CompanyDeleteView(LoginRequiredMixin, UserPassesTestMixin, DeleteView):
model = Company
success_url = '/ViewCompanys' #home page redirect when finished
#template_name = 'BankInformation/bank_del_update.html'
context_object_name = 'companys'
def test_func(self):
company = self.get_object()
if self.request.user == company.user:
return True
return False
class CompanyDetailView(LoginRequiredMixin, UserPassesTestMixin, DetailView):
model = Company
def test_func(self):
company = self.get_object()
if self.request.user == company.user:
return True
return False
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,096 | KarstenCollins/SeniorCapstone | refs/heads/master | /IncomeInformation/apps.py | from django.apps import AppConfig
class IncomeInformationConfig(AppConfig):
name = 'IncomeInformation'
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,097 | KarstenCollins/SeniorCapstone | refs/heads/master | /IncomeInformation/views.py | from django.shortcuts import render, redirect
from django.contrib.auth.forms import UserCreationForm
from .forms import IncomeCreateForm
from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin
from django.views.generic import ListView, DetailView, CreateView, DeleteView, UpdateView
from django.contrib import messages
from .models import Income
from .filters import IncomeFilter
from .forms import IncomeForm
class IncomeCreateView(LoginRequiredMixin, CreateView):
model = Income
#fields = ['source_name', 'amount', 'date_received']
form_class = IncomeForm
context_object_name = 'income'
def form_valid(self, form):
form.instance.user = self.request.user #sets author to logged in user
return super().form_valid(form)
class IncomeListView(LoginRequiredMixin, ListView):
model = Income
template_name = 'IncomeInformation/income_display.html'
context_object_name = 'income'
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['incomefilter'] = IncomeFilter(self.request.GET, queryset=self.get_queryset())
return context
def get_queryset(self): #only show logged in users' data
return self.model.objects.all().filter(user=self.request.user)
class IncomeUpdateView(LoginRequiredMixin, UserPassesTestMixin, UpdateView):
model = Income
fields = ['source_name', 'amount', 'date_received']
context_object_name = 'incomes'
def form_valid(self, form):
form.instance.user = self.request.user #sets author to logged in user
return super().form_valid(form)
def test_func(self):
income = self.get_object()
if self.request.user == income.user:
return True
return False
class IncomeDeleteView(LoginRequiredMixin, UserPassesTestMixin, DeleteView):
model = Income
success_url = '/ViewIncome' #home page redirect when finished
#template_name = 'BankInformation/bank_del_update.html'
context_object_name = 'incomes'
def test_func(self):
income = self.get_object()
if self.request.user == income.user:
return True
return False
class IncomeDetailView(LoginRequiredMixin, UserPassesTestMixin, DetailView):
model = Income
def test_func(self):
income = self.get_object()
if self.request.user == income.user:
return True
return False | {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,098 | KarstenCollins/SeniorCapstone | refs/heads/master | /CompanyInformation/models.py | from django.db import models
from django.contrib.auth.models import User
from django.urls import reverse
# Create your models here.
class Company(models.Model):
user = models.ForeignKey(User, on_delete=models.CASCADE, null=True, default="")
company_name = models.CharField( max_length=100)
phone_number = models.IntegerField(max_length=10)
address = models.CharField( max_length=100)
city = models.CharField( max_length=100)
state = models.CharField( max_length=2)
zip = models.CharField( max_length=6)
website = models.CharField( max_length=100)
def __str__(self):
return self.company_name
def get_absolute_url(self):
return reverse('view-company')
#kwargs={'pk': self.pk}
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,099 | KarstenCollins/SeniorCapstone | refs/heads/master | /cal/admin.py | from django.contrib import admin
from cal.models import Event
class EventMemberDelete(admin.ModelAdmin):
model = Event
list_display = ['event']
# Register your models here.
admin.site.register(Event)
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,100 | KarstenCollins/SeniorCapstone | refs/heads/master | /cal/urls.py | from django.conf.urls import url
from . import views
app_name = 'cal'
urlpatterns = [
url(r'index/', views.index, name='index'),
url(r'calendar/', views.CalendarView.as_view(), name='calendar'),
url(r'event/new/', views.event, name='event_new'),
url(r'event/edit/(?P<event_id>\d+)/', views.event, name='event_edit'),
#url(r'event/<int:pk>/remove', views.EventDeleteView.as_view(), name='remove_event'),
url(r'listcalendar/', views.event_list_view, name='list-calendar'),
url(r'event/delete/<id>', views.event_delete_view, name='event-delete'),
url(r'return_home/', views.return_home, name='return_home')
]
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,101 | KarstenCollins/SeniorCapstone | refs/heads/master | /BankInformation/apps.py | from django.apps import AppConfig
class BankinformationConfig(AppConfig):
name = 'BankInformation'
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,102 | KarstenCollins/SeniorCapstone | refs/heads/master | /SubmitData/urls.py | from django.urls import include, path
from .views import (
PostListView,
PostDetailView,
PostCreateView,
BillStatement,
PostUpdateView,
PostDeleteView,
BillExport,
)
from BankInformation import views as bank_views
from IncomeInformation import views as income_views
from CompanyInformation import views as company_views
from . import views as data_views
from cal import views as cal_views
urlpatterns = [
path('', PostListView.as_view(), name='Submit-Data'),
path('post/<int:pk>/', PostDetailView.as_view(), name='data-detail'),
path('post/new/', PostCreateView.as_view(), name='create-data'),
path('post/<int:pk>/update', PostUpdateView.as_view(), name='update-data'),
path('post/<int:pk>/delete', PostDeleteView.as_view(), name='delete-data'),
path('DownloadBills', BillExport, name='download-bills'),
path('ViewBanks/', bank_views.BankListView.as_view(), name='view-banks'),
path('bank/<int:pk>/delete/', bank_views.BankDeleteView.as_view(), name='delete-bank'),
path('bank/<int:pk>/update/', bank_views.BankUpdateView.as_view(), name='update-bank'),
path('BankInfo/', bank_views.BankCreateView.as_view(), name='create-bank'),
path('bank/<int:pk>/', bank_views.BankDetailView.as_view(), name='bank-detail'),
path('ViewIncome/', income_views.IncomeListView.as_view(), name='view-incomes'),
path('income/<int:pk>/delete/', income_views.IncomeDeleteView.as_view(), name='delete-income'),
path('income/<int:pk>/update/', income_views.IncomeUpdateView.as_view(), name='update-income'),
path('IncomeInfo/', income_views.IncomeCreateView.as_view(), name='create-income'),
path('income/<int:pk>/', income_views.IncomeDetailView.as_view(), name='income-detail'),
path('CompanyInfo/', company_views.CompanyCreateView.as_view(), name='create-company'),
path('CompanyIncome/', company_views.CompanyListView.as_view(), name='view-company'),
path('ViewCompanys/', company_views.CompanyListView.as_view(), name='view-companys'),
path('company/<int:pk>/', company_views.CompanyDetailView.as_view(), name='company-detail'),
path('company/<int:pk>/delete/', company_views.CompanyDeleteView.as_view(), name='delete-company'),
path('company/<int:pk>/update/', company_views.CompanyUpdateView.as_view(), name='update-company'),
path('BillsNotPaid/', data_views.IsPaidView.as_view(), name='is-paid'),
path('Summaries/', data_views.YearlyMonthlySummaryView.as_view(), name='view-summaries'),
path(r'index/', cal_views.index, name='index'),
path(r'calendar/', cal_views.CalendarView.as_view(), name='calendar'),
path(r'event/new/', cal_views.event, name='event_new'),
path(r'event/edit/(<event_id>\d+)/', cal_views.event, name='event_edit'),
#path('event/<int:pk>/remove', cal_views.EventDeleteView.as_view(), name='remove_event'),
path(r'listcalendar/', cal_views.event_list_view, name='list-calendar'),
path(r'event/delete/<id>', cal_views.event_delete_view, name='event-delete'),
]
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,103 | KarstenCollins/SeniorCapstone | refs/heads/master | /SubmitData/migrations/0011_auto_20210504_1837.py | # Generated by Django 3.1.7 on 2021-05-05 01:37
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('SubmitData', '0010_auto_20210504_1836'),
]
operations = [
migrations.AlterField(
model_name='post',
name='is_paid',
field=models.BooleanField(default=0, help_text='Everything below is optional. These are recommended to be filled out if using a credit card'),
),
]
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,104 | KarstenCollins/SeniorCapstone | refs/heads/master | /CompanyInformation/apps.py | from django.apps import AppConfig
class CompanyInformationConfig(AppConfig):
name = 'CompanyInformation'
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,105 | KarstenCollins/SeniorCapstone | refs/heads/master | /SubmitData/migrations/0011_auto_20210504_1751.py | # Generated by Django 3.1.7 on 2021-05-05 00:51
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('SubmitData', '0010_auto_20210504_1750'),
]
operations = [
migrations.AlterField(
model_name='post',
name='is_paid',
field=models.BooleanField(default=0, help_text='Everything below is optional. Recommended if using a credit card.'),
),
]
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,106 | KarstenCollins/SeniorCapstone | refs/heads/master | /cal/models.py | from django.db import models
from django.urls import reverse, reverse_lazy
class Event(models.Model):
title = models.CharField(max_length=200)
description = models.TextField()
start_time = models.DateTimeField()
end_time = models.DateTimeField()
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse('cal:event-edit', args=(self.id,))
#return reverse_lazy('cal:remove_event', args=(self.id,))
@property
def get_html_url(self):
url = reverse('cal:event_edit', args=(self.id,))
#url = reverse_lazy('cal:remove_event', args=(self.id,))
return f'<a href="{url}"> {self.title} </a>'
class EventMemberDelete(models.Model):
event = models.ForeignKey(Event, on_delete=models.CASCADE)
class Meta:
unique_together = ['event']
def __str__(self):
return str(self.user)
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,107 | KarstenCollins/SeniorCapstone | refs/heads/master | /BankInformation/views.py | from django.shortcuts import render, redirect
from django.contrib.auth.forms import UserCreationForm
from .forms import BankCreateForm
from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin
from django.views.generic import ListView, DetailView, CreateView, DeleteView, UpdateView
from django.contrib import messages
from .models import Bank
#def BankCreateView(request):
#if request.method == 'Post':
#form = BankCreateForm(request.POST)
#if form.is_valid():
# form.save()
# messages.success(request, f'Your bank has been submitted!')
# return redirect('BankInfo/')
#else:
# form = BankCreateForm()
#return render(request, 'BankInformation/bank_form.html', {'form' : form})
class BankCreateView(LoginRequiredMixin, CreateView):
model = Bank
fields = ['bank_name', 'bank_acc_number', 'nickname', 'account_type', 'routing_number', 'notes']
context_object_name = 'banks'
def form_valid(self, form):
form.instance.user = self.request.user #sets author to logged in user
return super().form_valid(form)
class BankListView(LoginRequiredMixin, ListView):
model = Bank
template_name = 'BankInformation/bank_display.html'
context_object_name = 'banks'
def get_queryset(self): #only show logged in users' data
return self.model.objects.all().filter(user=self.request.user)
class BankUpdateView(LoginRequiredMixin, UserPassesTestMixin, UpdateView):
model = Bank
fields = ['bank_name', 'bank_acc_number', 'nickname', 'account_type', 'routing_number', 'notes']
context_object_name = 'banks'
def form_valid(self, form):
form.instance.user = self.request.user #sets author to logged in user
return super().form_valid(form)
def test_func(self):
bank = self.get_object()
if self.request.user == bank.user:
return True
return False
class BankDeleteView(LoginRequiredMixin, UserPassesTestMixin, DeleteView):
model = Bank
success_url = '/ViewBanks' #home page redirect when finished
#template_name = 'BankInformation/bank_del_update.html'
context_object_name = 'banks'
def test_func(self):
bank = self.get_object()
if self.request.user == bank.user:
return True
return False
class BankDetailView(LoginRequiredMixin, UserPassesTestMixin, DetailView):
model = Bank
def test_func(self):
bank = self.get_object()
if self.request.user == bank.user:
return True
return False | {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,108 | KarstenCollins/SeniorCapstone | refs/heads/master | /SubmitData/migrations/0010_auto_20210504_1836.py | # Generated by Django 3.1.7 on 2021-05-05 01:36
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('SubmitData', '0009_auto_20210427_1730'),
]
operations = [
migrations.AddField(
model_name='post',
name='adjustment',
field=models.IntegerField(blank=True, default='0'),
),
migrations.AddField(
model_name='post',
name='credit',
field=models.IntegerField(blank=True, default='0'),
),
migrations.AddField(
model_name='post',
name='interest_charges',
field=models.IntegerField(blank=True, default='0'),
),
migrations.AddField(
model_name='post',
name='late_fees',
field=models.IntegerField(blank=True, default='0'),
),
migrations.AddField(
model_name='post',
name='payments',
field=models.IntegerField(blank=True, default='0'),
),
migrations.AddField(
model_name='post',
name='previous_balance',
field=models.IntegerField(blank=True, default='0'),
),
]
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,109 | KarstenCollins/SeniorCapstone | refs/heads/master | /BankInformation/forms.py | from django import forms
from django.contrib.auth.models import User
from .models import Bank
class BankCreateForm(forms.ModelForm):
class Meta:
model = Bank
fields = ['bank_name', 'bank_acc_number', 'nickname', 'account_type', 'routing_number', 'notes'] | {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,110 | KarstenCollins/SeniorCapstone | refs/heads/master | /users/migrations/0003_auto_20210420_1650.py | # Generated by Django 3.2 on 2021-04-20 23:50
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('users', '0002_auto_20210407_2127'),
]
operations = [
migrations.AddField(
model_name='profile',
name='first_name',
field=models.CharField(default='', max_length=30),
),
migrations.AddField(
model_name='profile',
name='last_name',
field=models.CharField(default='', max_length=30),
),
]
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,111 | KarstenCollins/SeniorCapstone | refs/heads/master | /BankInformation/models.py | from django.db import models
from django.contrib.auth.models import User
from django.urls import reverse
# Create your models here.
class Bank(models.Model):
user = models.ForeignKey(User, on_delete=models.CASCADE, null=True)
bank_name = models.CharField(max_length=255)
nickname = models.CharField(max_length=255, blank=True)
account_type = models.CharField(max_length=255)
bank_acc_number = models.IntegerField()
routing_number = models.IntegerField()
notes = models.TextField(blank=True)
def __str__(self):
return self.bank_name
def get_absolute_url(self):
return reverse('view-banks')
#kwargs={'pk': self.pk} | {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,112 | KarstenCollins/SeniorCapstone | refs/heads/master | /SubmitData/migrations/0012_merge_20210505_2122.py | # Generated by Django 3.1.7 on 2021-05-06 04:22
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('SubmitData', '0011_auto_20210504_1837'),
('SubmitData', '0011_auto_20210504_1751'),
]
operations = [
]
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,113 | KarstenCollins/SeniorCapstone | refs/heads/master | /SubmitData/migrations/0007_post_payment_method.py | # Generated by Django 3.1.7 on 2021-04-11 22:14
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('SubmitData', '0006_auto_20210411_1504'),
]
operations = [
migrations.AddField(
model_name='post',
name='payment_method',
field=models.CharField(default='', max_length=50),
),
]
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,114 | KarstenCollins/SeniorCapstone | refs/heads/master | /SubmitData/forms.py | from django import forms
from django.forms import ModelForm
from django.forms import widgets
from django.forms.widgets import Widget
from .models import Post
class DateInput(forms.DateInput):
input_type='date'
class PostForm(ModelForm):
class Meta:
model = Post
fields = ['title', 'company_name', 'account_number', 'statement_date', 'due_date',
'amount', 'payment_method', 'is_paid']
widgets = {
'statement_date' : DateInput(),
'due_date' : DateInput(),
}
#'payment_method', 'is_paid', 'previous_balance','minimum_payment', 'payments', 'adjustment', 'credit', 'late_fees', 'interest_charges'
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,115 | KarstenCollins/SeniorCapstone | refs/heads/master | /SubmitData/migrations/0015_post_minimum_payment.py | # Generated by Django 3.1.7 on 2021-05-20 18:12
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('SubmitData', '0014_auto_20210505_2124'),
]
operations = [
migrations.AddField(
model_name='post',
name='minimum_payment',
field=models.IntegerField(blank=True, default='0'),
),
]
| {"/SubmitData/filters.py": ["/SubmitData/models.py"], "/CompanyInformation/forms.py": ["/CompanyInformation/models.py"], "/IncomeInformation/filters.py": ["/IncomeInformation/models.py"], "/IncomeInformation/forms.py": ["/IncomeInformation/models.py"], "/SubmitData/views.py": ["/SubmitData/models.py", "/SubmitData/filters.py", "/SubmitData/forms.py"], "/IncomeInformation/admin.py": ["/IncomeInformation/models.py"], "/CompanyInformation/views.py": ["/CompanyInformation/forms.py", "/CompanyInformation/models.py"], "/IncomeInformation/views.py": ["/IncomeInformation/forms.py", "/IncomeInformation/models.py", "/IncomeInformation/filters.py"], "/cal/admin.py": ["/cal/models.py"], "/SubmitData/urls.py": ["/SubmitData/views.py"], "/BankInformation/views.py": ["/BankInformation/forms.py", "/BankInformation/models.py"], "/BankInformation/forms.py": ["/BankInformation/models.py"], "/SubmitData/forms.py": ["/SubmitData/models.py"]} |
50,116 | QIICR/SlicerDevelopmentToolbox | refs/heads/master | /SlicerDevelopmentToolboxUtils/constants.py | import qt
class DICOMTAGS:
PATIENT_NAME = '0010,0010'
PATIENT_ID = '0010,0020'
PATIENT_BIRTH_DATE = '0010,0030'
SERIES_DESCRIPTION = '0008,103E'
SERIES_NUMBER = '0020,0011'
INSTANCE_NUMBER = '0020,0013'
STUDY_DATE = '0008,0020'
STUDY_ID = '0020,0010'
STUDY_TIME = '0008,0030'
ACQUISITION_TIME = '0008,0032'
class COLOR:
RED = qt.QColor(qt.Qt.red)
YELLOW = qt.QColor(qt.Qt.yellow)
GREEN = qt.QColor(qt.Qt.darkGreen)
GRAY = qt.QColor(qt.Qt.gray)
class STYLE:
WHITE_BACKGROUND = 'background-color: rgb(255,255,255)'
LIGHT_GRAY_BACKGROUND = 'background-color: rgb(230,230,230)'
ORANGE_BACKGROUND = 'background-color: rgb(255,102,0)'
YELLOW_BACKGROUND = 'background-color: yellow;'
GREEN_BACKGROUND = 'background-color: green;'
GRAY_BACKGROUND = 'background-color: gray;'
RED_BACKGROUND = 'background-color: red;'
class FileExtension(object):
TXT = ".TXT"
NRRD = ".nrrd"
FCSV = ".fcsv"
H5 = ".h5"
VTK = ".vtk" | {"/SlicerDevelopmentToolboxUtils/buttons.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/widgets.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/helpers.py": ["/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/widgets.py": ["/SlicerDevelopmentToolboxUtils/constants.py", "/SlicerDevelopmentToolboxUtils/decorators.py", "/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/helpers.py", "/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/module/logic.py": ["/SlicerDevelopmentToolboxUtils/module/base.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py": ["/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py"], "/SlicerDevelopmentToolboxUtils/module/plugin.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/step.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/session.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/icons.py": ["/SlicerDevelopmentToolboxUtils/decorators.py"], "/SlicerDevelopmentToolboxUtils/forms/FormsDialog.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py"], "/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGenerator.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/module/base.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/decorators.py"]} |
50,117 | QIICR/SlicerDevelopmentToolbox | refs/heads/master | /SlicerDevelopmentToolboxUtils/buttons.py | import vtk
import qt
import slicer
from SlicerDevelopmentToolboxUtils.mixins import ModuleWidgetMixin, GeneralModuleMixin
from SlicerDevelopmentToolboxUtils.widgets import SettingsMessageBox, DICOMConnectionTestWidget
from SlicerDevelopmentToolboxUtils.icons import Icons
class BasicIconButton(qt.QPushButton, GeneralModuleMixin):
""" Base class for icon based qt.QPushButton
Args:
text (str, optional): text to be displayed for the button
parent (qt.QWidget, optional): parent of the button
"""
_ICON=None
def __init__(self, text="", parent=None, **kwargs):
qt.QPushButton.__init__(self, text, parent, **kwargs)
if not self._ICON:
raise ValueError("_ICON needs to be defined by subclasses")
self.setIcon(self._ICON)
self._connectSignals()
self._processKwargs(**kwargs)
def _connectSignals(self):
self.destroyed.connect(self._onAboutToBeDestroyed)
def _onAboutToBeDestroyed(self, obj):
obj.destroyed.disconnect(self._onAboutToBeDestroyed)
class DICOMConnectionTestButton(BasicIconButton):
_ICON = Icons.connection
def __init__(self, text="", parent=None, **kwargs):
BasicIconButton.__init__(self, text, parent, **kwargs)
def _connectSignals(self):
super(DICOMConnectionTestButton, self)._connectSignals()
self.clicked.connect(self.__onClicked)
def __onClicked(self):
dicomTestWidget = DICOMConnectionTestWidget()
dicomTestWidget.show()
class CheckableIconButton(BasicIconButton):
""" Base class for icon based checkable qt.QPushButton. Needs to implement method 'onToggled'
Args:
text (str, optional): text to be displayed for the button
parent (qt.QWidget, optional): parent of the button
"""
def __init__(self, text="", parent=None, **kwargs):
BasicIconButton.__init__(self, text, parent, **kwargs)
self.checkable = True
def _connectSignals(self):
super(CheckableIconButton, self)._connectSignals()
self.toggled.connect(self._onToggled)
def _onToggled(self, checked):
raise NotImplementedError()
class ModuleSettingsButton(BasicIconButton):
""" qt.QPushButton that upon click displays the qt.QSettings() for the delivered moduleName in a separate dialog
Args:
moduleName (str): Name of the module whose settings you want to see (modify).
text (str, optional): text to be displayed for the button
See Also: :paramref:`SlicerDevelopmentToolboxUtils.widgets.SettingsMessageBox`
"""
def __init__(self, moduleName, text="", parent=None, **kwargs):
self.moduleName = moduleName
self._ICON = Icons.settings
super(ModuleSettingsButton, self).__init__(text, parent, **kwargs)
def _connectSignals(self):
super(ModuleSettingsButton, self)._connectSignals()
self.clicked.connect(self.__onClicked)
def __onClicked(self):
settings = SettingsMessageBox(self.moduleName, slicer.util.mainWindow())
settings.show()
class LayoutButton(CheckableIconButton):
""" Base class for layout specific buttons
LayoutButton can be subclassed where each subclass needs to define a layout. Once the button is pushed, 3D Slicer
switches to the defined layout. LayoutButton reacts to layout changes of Slicer where the LayoutButton adjusts it's
check state depending on the currently chosen layout.
Args:
text (str, optional): text to be displayed for the button
parent (qt.QWidget, optional): parent of the button
Note:
Subclasses need to define class member 'LAYOUT'. Available layouts are listed on the referenced page.
See also:
http://apidocs.slicer.org/master/classvtkMRMLLayoutNode.html
"""
LAYOUT=None
@property
def layoutManager(self):
""" Returns 3D Slicer layout manager
Returns:
slicer.app.layoutManager()
"""
return slicer.app.layoutManager()
def __init__(self, text="", parent=None, **kwargs):
super(LayoutButton, self).__init__(text, parent, **kwargs)
if not self.LAYOUT:
raise NotImplementedError("Member variable LAYOUT needs to be defined by all deriving classes")
self._onLayoutChanged(self.layoutManager.layout)
def _connectSignals(self):
super(LayoutButton, self)._connectSignals()
self.layoutManager.layoutChanged.connect(self._onLayoutChanged)
def _onAboutToBeDestroyed(self, obj):
super(LayoutButton, self)._onAboutToBeDestroyed(obj)
if self.layoutManager:
self.layoutManager.layoutChanged.disconnect(self._onLayoutChanged)
def _onLayoutChanged(self, layout):
self.checked = self.LAYOUT == layout
def _onToggled(self, checked):
if checked and self.layoutManager.layout != self.LAYOUT:
self.layoutManager.setLayout(self.LAYOUT)
if not checked and self.LAYOUT == self.layoutManager.layout:
self._onLayoutChanged(self.LAYOUT)
class RedSliceLayoutButton(LayoutButton):
""" LayoutButton inherited class which represents a button for the SlicerLayoutOneUpRedSliceView including the icon.
Args:
text (str, optional): text to be displayed for the button
parent (qt.QWidget, optional): parent of the button
.. code-block:: python
from SlicerDevelopmentToolboxUtils.buttons import RedSliceLayoutButton
button = RedSliceLayoutButton()
button.show()
"""
LAYOUT = slicer.vtkMRMLLayoutNode.SlicerLayoutOneUpRedSliceView
def __init__(self, text="", parent=None, **kwargs):
self._ICON = Icons.layout_one_up_red_slice_view
super(RedSliceLayoutButton, self).__init__(text, parent, **kwargs)
self.toolTip = "Red Slice Only Layout"
class FourUpLayoutButton(LayoutButton):
""" LayoutButton inherited class which represents a button for the SlicerLayoutFourUpView including the icon.
Args:
text (str, optional): text to be displayed for the button
parent (qt.QWidget, optional): parent of the button
.. code-block:: python
from SlicerDevelopmentToolboxUtils.buttons import FourUpLayoutButton
button = FourUpLayoutButton()
button.show()
"""
LAYOUT = slicer.vtkMRMLLayoutNode.SlicerLayoutFourUpView
def __init__(self, text="", parent=None, **kwargs):
self._ICON = Icons.layout_four_up_view
super(FourUpLayoutButton, self).__init__(text, parent, **kwargs)
self.toolTip = "Four-Up Layout"
class FourUpTableViewLayoutButton(LayoutButton):
""" LayoutButton inherited class which represents a button for the SlicerLayoutFourUpTableView including the icon.
Args:
text (str, optional): text to be displayed for the button
parent (qt.QWidget, optional): parent of the button
.. code-block:: python
from SlicerDevelopmentToolboxUtils.buttons import FourUpTableViewLayoutButton
button = FourUpTableViewLayoutButton()
button.show()
"""
LAYOUT = slicer.vtkMRMLLayoutNode.SlicerLayoutFourUpTableView
def __init__(self, text="", parent=None, **kwargs):
self._ICON = Icons.layout_four_up_table_view
super(FourUpTableViewLayoutButton, self).__init__(text, parent, **kwargs)
self.toolTip = "Four-Up Table Layout"
class FourUpPlotViewLayoutButton(LayoutButton):
""" LayoutButton inherited class which represents a button for the SlicerLayoutFourUpPlotView including the icon.
Args:
text (str, optional): text to be displayed for the button
parent (qt.QWidget, optional): parent of the button
.. code-block:: python
from SlicerDevelopmentToolboxUtils.buttons import FourUpPlotViewLayoutButton
button = FourUpPlotViewLayoutButton()
button.show()
"""
LAYOUT = slicer.vtkMRMLLayoutNode.SlicerLayoutFourUpPlotView
def __init__(self, text="", parent=None, **kwargs):
self._ICON = Icons.layout_four_up_plot_view
super(FourUpPlotViewLayoutButton, self).__init__(text, parent, **kwargs)
self.toolTip = "Four-Up Plot Layout"
class SideBySideLayoutButton(LayoutButton):
""" LayoutButton inherited class which represents a button for the SlicerLayoutSideBySideView including the icon.
Args:
text (str, optional): text to be displayed for the button
parent (qt.QWidget, optional): parent of the button
.. code-block:: python
from SlicerDevelopmentToolboxUtils.buttons import SideBySideLayoutButton
button = SideBySideLayoutButton()
button.show()
"""
LAYOUT = slicer.vtkMRMLLayoutNode.SlicerLayoutSideBySideView
def __init__(self, text="", parent=None, **kwargs):
self._ICON = Icons.layout_side_by_side_view
super(SideBySideLayoutButton, self).__init__(text, parent, **kwargs)
self.toolTip = "Side by Side Layout"
class CrosshairButton(CheckableIconButton):
""" Represents a button for enabling/disabling crosshair for better slice view coordination.
Args:
text (str, optional): text to be displayed for the button
parent (qt.QWidget, optional): parent of the button
Attributes:
CursorPositionModifiedEvent (slicer.vtkMRMLCrosshairNode.CursorPositionModifiedEvent)
_DEFAULT_CROSSHAIR_MODE (enum): defining the crosshair display mode (see referenced web page)
.. code-block:: python
from SlicerDevelopmentToolboxUtils.buttons import CrosshairButton
button = CrosshairButton()
button.show()
See Also: http://apidocs.slicer.org/master/classvtkMRMLCrosshairNode.html
"""
CursorPositionModifiedEvent = slicer.vtkMRMLCrosshairNode.CursorPositionModifiedEvent
""" Invoked whenever crosshair is enabled and cursor position changes """
_DEFAULT_CROSSHAIR_MODE = slicer.vtkMRMLCrosshairNode.ShowSmallBasic
@property
def crosshairMode(self):
return self._crosshairMode
@crosshairMode.setter
def crosshairMode(self, mode):
if not type(mode) is int:
raise ValueError("Mode seems not to be valid")
self._crosshairMode = mode
self.crosshairNode.SetCrosshairMode(mode)
def __init__(self, text="", parent=None, **kwargs):
self._ICON = Icons.crosshair
super(CrosshairButton, self).__init__(text, parent, **kwargs)
self.toolTip = "Display crosshair"
self.crosshairNodeObserverTag = None
self.crosshairNode = slicer.mrmlScene.GetNthNodeByClass(0, 'vtkMRMLCrosshairNode')
self.crosshairNodeModifiedObserver = self.crosshairNode.AddObserver(vtk.vtkCommand.ModifiedEvent,
self._onCrosshairNodeModified)
self._crosshairMode = self._DEFAULT_CROSSHAIR_MODE
self.sliceIntersectionEnabled = False
def _onAboutToBeDestroyed(self, obj):
super(CrosshairButton, self)._onAboutToBeDestroyed(obj)
self._disconnectCrosshairNode()
if self.crosshairNode and self.crosshairNodeModifiedObserver:
self.crosshairNodeModifiedObserver = self.crosshairNode.RemoveObserver(self.crosshairNodeModifiedObserver)
def setSliceIntersectionEnabled(self, enabled):
self.sliceIntersectionEnabled = enabled
def _onCrosshairNodeModified(self, caller, event):
mode = self.crosshairNode.GetCrosshairMode()
self.checked = not mode is slicer.vtkMRMLCrosshairNode.NoCrosshair
def _onToggled(self, checked):
if checked:
self._connectCrosshairNode()
else:
self._disconnectCrosshairNode()
def _connectCrosshairNode(self):
if not self.crosshairNodeObserverTag:
self.crosshairNodeObserverTag = self.crosshairNode.AddObserver(self.CursorPositionModifiedEvent,
self._onCursorPositionChanged)
self.crosshairNode.SetCrosshairMode(self.crosshairMode)
self._showSliceIntersection(self.sliceIntersectionEnabled)
def _onCursorPositionChanged(self, observee=None, event=None):
self.invokeEvent(self.CursorPositionModifiedEvent, self.crosshairNode)
def _disconnectCrosshairNode(self):
if self.crosshairNode and self.crosshairNodeObserverTag:
self.crosshairNode.RemoveObserver(self.crosshairNodeObserverTag)
self.crosshairNodeObserverTag = None
self.crosshairNode.SetCrosshairMode(slicer.vtkMRMLCrosshairNode.NoCrosshair)
self._showSliceIntersection(False)
def _showSliceIntersection(self, show):
sliceDisplayNodes = slicer.util.getNodesByClass("vtkMRMLSliceDisplayNode")
for sliceDisplayNode in sliceDisplayNodes:
sliceDisplayNode.SetIntersectingSlicesVisibility(1)
# Force update of slice views
sliceNodes = slicer.util.getNodesByClass("vtkMRMLSliceNode")
for sliceNode in sliceNodes:
sliceNode.Modified()
| {"/SlicerDevelopmentToolboxUtils/buttons.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/widgets.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/helpers.py": ["/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/widgets.py": ["/SlicerDevelopmentToolboxUtils/constants.py", "/SlicerDevelopmentToolboxUtils/decorators.py", "/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/helpers.py", "/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/module/logic.py": ["/SlicerDevelopmentToolboxUtils/module/base.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py": ["/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py"], "/SlicerDevelopmentToolboxUtils/module/plugin.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/step.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/session.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/icons.py": ["/SlicerDevelopmentToolboxUtils/decorators.py"], "/SlicerDevelopmentToolboxUtils/forms/FormsDialog.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py"], "/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGenerator.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/module/base.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/decorators.py"]} |
50,118 | QIICR/SlicerDevelopmentToolbox | refs/heads/master | /SlicerDevelopmentToolboxUtils/decorators.py | from functools import wraps
import itertools
import logging
import inspect
import slicer
class logmethod(object):
""" This decorator can be used for logging methods without the need of reimplementing log messages over and over again.
The decorator logs information about the called method name including caller and arguments.
.. code-block:: python
from SlicerDevelopmentToolboxUtils.decorators import logmethod
@logmethod()
def sub(x,y, switch=False):
return x -y if not switch else y-x
@logmethod(level=logging.INFO)
def sub(x,y, switch=False):
return x -y if not switch else y-x
"""
def __init__(self, level=logging.DEBUG):
self.logLevel = level
def __call__(self, func):
def wrapped_f(*args, **kwargs):
args_map = {}
try:
if args or kwargs:
args_map = inspect.getcallargs(func, *args, **kwargs)
except TypeError:
pass
className = ""
if 'self' in args_map:
cls = args_map['self'].__class__
className = cls.__name__ + '.'
try:
frame = inspect.stack()[1][0]
fileName = frame.f_code.co_filename
lineNo = frame.f_lineno
callerMethod = frame.f_code.co_name
callerClass = frame.f_locals["self"].__class__.__name__
except (KeyError, IndexError):
callerClass = callerMethod = lineNo = fileName = ""
caller = ""
if callerClass != "" and callerMethod != "":
caller = " from {}.{}".format(callerClass, callerMethod)
logging.log(self.logLevel, "Called {}{}{} with args {} and "
"kwargs {} from file {} line {} ".format(className, func.__name__, caller, args,
kwargs, fileName, lineNo))
return func(*args, **kwargs)
return wrapped_f
class onModuleSelected(object):
""" This decorator can be used for executing the decorated function/method only if a certain Slicer module with name
moduleName is currently selected
.. code-block:: python
from SlicerDevelopmentToolboxUtils.decorators import onModuleSelected
@onModuleSelected(moduleName="SliceTracker")
def onLayoutChanged(self, layout=None):
print("layout changed")
"""
def __init__(self, moduleName):
self.moduleName = moduleName
def __call__(self, func):
def wrapped_f(*args, **kwargs):
currentModuleName = slicer.util.selectedModule()
if currentModuleName == self.moduleName:
return func(*args, **kwargs)
else:
logging.debug("Method {} not executed: \n Selected module: {}\n Expected module: {}"
.format(func, currentModuleName, self.moduleName))
return wrapped_f
def onExceptionReturnNone(func):
""" Whenever an exception occurs within the decorated function, this decorator will return None
.. code-block:: python
from SlicerDevelopmentToolboxUtils.decorators import onExceptionReturnNone
@onExceptionReturnNone
def getElement(key, dictionary):
return dictionary[key]
result = getElement('foobar', {'foo':1, 'bar':2}) # no foobar in dictionary
"""
@wraps(func)
def wrapper(*args, **kwargs):
try:
return func(*args, **kwargs)
except (IndexError, AttributeError, KeyError):
return None
return wrapper
def onExceptionReturnFalse(func):
""" Whenever an exception occurs within the decorated function, this decorator will return False
.. doctest::
>>> from SlicerDevelopmentToolboxUtils.decorators import onExceptionReturnFalse
>>> @onExceptionReturnFalse
... def getElement(key, dictionary):
... return dictionary[key]
>>> result = getElement('foobar', {'foo':1, 'bar':2}) # no foobar in dictionary
>>> result is False
"""
@wraps(func)
def wrapper(*args, **kwargs):
try:
return func(*args, **kwargs)
except:
return False
return wrapper
def onReturnProcessEvents(func):
""" After running the decorated function slicer.app.processEvents() will be executed
"""
@wraps(func)
def wrapper(*args, **kwargs):
func(*args, **kwargs)
slicer.app.processEvents()
return wrapper
def beforeRunProcessEvents(func):
""" Before running the decorated function slicer.app.processEvents() will be executed
"""
@wraps(func)
def wrapper(*args, **kwargs):
slicer.app.processEvents()
func(*args, **kwargs)
return wrapper
def callCount(level=logging.DEBUG):
""" This decorator is useful for debugging purposes where one wants to know the call count of the decorated function.
"""
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
args_map = {}
if args or kwargs:
args_map = inspect.getcallargs(func, *args, **kwargs)
className = ""
if 'self' in args_map:
cls = args_map['self'].__class__
className = cls.__name__ + '.'
wrapper.count += 1
logging.log(level, "{}{} called {} times".format(className, func.__name__, wrapper.count))
return func(*args, **kwargs)
wrapper.count = 0
return wrapper
return decorator
def timer(func):
""" This decorator can be used for profiling a method/function by printing the elapsed time after execution.
"""
def _new_function(*args, **kwargs):
import time
startTime = time.time()
x = func(*args, **kwargs)
duration = time.time() - startTime
print("{} ran in: {0} seconds".format(func.__name__, duration))
return x
return _new_function
class processEventsEvery:
""" Decorator for executing a method/function every n milli seconds.
"""
def __init__(self, interval=100):
import qt
self.timer = qt.QTimer()
self.timer.setInterval(interval)
self.timer.connect('timeout()', self.onTriggered)
def __del__(self):
self.timer.disconnect('timeout()')
def __call__(self, func):
def wrapped_f(*args, **kwargs):
self.timer.start()
func(*args, **kwargs)
self.timer.stop()
return wrapped_f
def onTriggered(self):
slicer.app.processEvents()
def priorCall(functionToCall):
""" This decorator calls functionToCall prior to the decorated function.
Args:
functionToCall(function): function to be called prior(before) the decorated function
"""
def decorator(func):
@wraps(func)
def f(*args, **kwargs):
logging.debug("calling {} before {}".format(functionToCall.__name__, func.__name__))
functionToCall(args[0])
func(*args, **kwargs)
return f
return decorator
def postCall(functionToCall):
""" This decorator calls functionToCall after the decorated function.
Args:
functionToCall(function): function to be called after the decorated function
"""
def decorator(func):
@wraps(func)
def f(*args, **kwargs):
logging.debug("calling {} after {}".format(functionToCall.__name__, func.__name__))
func(*args, **kwargs)
functionToCall(args[0])
return f
return decorator
def singleton(cls):
""" This decorator makes sure that only one instance of the decorated class will be created (singleton).
See Also: http://stackoverflow.com/questions/12305142/issue-with-singleton-python-call-two-times-init
"""
instances = {}
def getinstance(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return getinstance
class classproperty(object):
""" This decorator enables adding properties to classes that can be called without instantiating an object
See Also: https://stackoverflow.com/a/13624858
"""
def __init__(self, fget):
self.fget = fget
def __get__(self, owner_self, owner_cls):
return self.fget(owner_cls)
| {"/SlicerDevelopmentToolboxUtils/buttons.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/widgets.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/helpers.py": ["/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/widgets.py": ["/SlicerDevelopmentToolboxUtils/constants.py", "/SlicerDevelopmentToolboxUtils/decorators.py", "/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/helpers.py", "/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/module/logic.py": ["/SlicerDevelopmentToolboxUtils/module/base.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py": ["/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py"], "/SlicerDevelopmentToolboxUtils/module/plugin.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/step.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/session.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/icons.py": ["/SlicerDevelopmentToolboxUtils/decorators.py"], "/SlicerDevelopmentToolboxUtils/forms/FormsDialog.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py"], "/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGenerator.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/module/base.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/decorators.py"]} |
50,119 | QIICR/SlicerDevelopmentToolbox | refs/heads/master | /SlicerDevelopmentToolboxUtils/exceptions.py |
class DICOMValueError(ValueError):
pass
class PreProcessedDataError(ValueError):
pass
class UnknownSeriesError(ValueError):
pass
class NoEligibleSeriesFoundError(ValueError):
pass | {"/SlicerDevelopmentToolboxUtils/buttons.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/widgets.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/helpers.py": ["/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/widgets.py": ["/SlicerDevelopmentToolboxUtils/constants.py", "/SlicerDevelopmentToolboxUtils/decorators.py", "/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/helpers.py", "/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/module/logic.py": ["/SlicerDevelopmentToolboxUtils/module/base.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py": ["/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py"], "/SlicerDevelopmentToolboxUtils/module/plugin.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/step.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/session.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/icons.py": ["/SlicerDevelopmentToolboxUtils/decorators.py"], "/SlicerDevelopmentToolboxUtils/forms/FormsDialog.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py"], "/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGenerator.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/module/base.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/decorators.py"]} |
50,120 | QIICR/SlicerDevelopmentToolbox | refs/heads/master | /SlicerDevelopmentToolboxUtils/helpers.py | import ast
import logging
import os
import sys
import urllib
from urllib.request import FancyURLopener
import vtk
import qt
import slicer
from DICOMLib import DICOMProcess, DICOMStoreSCPProcess
from SlicerDevelopmentToolboxUtils.events import SlicerDevelopmentToolboxEvents
from SlicerDevelopmentToolboxUtils.mixins import ModuleWidgetMixin, ModuleLogicMixin, ParameterNodeObservationMixin
class SampleDataDownloader(FancyURLopener, ParameterNodeObservationMixin):
""" Helper class for retrieving sample data from an url """
StatusChangedEvent = SlicerDevelopmentToolboxEvents.StatusChangedEvent
""" Invoked whenever the current status changed """
CanceledEvent = SlicerDevelopmentToolboxEvents.CanceledEvent
""" Invoked if download was canceled """
FinishedEvent = SlicerDevelopmentToolboxEvents.FinishedEvent
""" Invoked once download was finished """
FailedEvent = SlicerDevelopmentToolboxEvents.FailedEvent
""" Invoked if download failed """
def __init__(self, enableLogging=False):
super(SampleDataDownloader, self).__init__()
self._loggingEnabled = enableLogging
self.isDownloading = False
self.resetAndInitialize()
def __del__(self):
super(SampleDataDownloader, self).__del__()
def resetAndInitialize(self):
""" Resetting and reinitializing class members. Cancels download if there is one currently running. """
self._canceled=False
if self.isDownloading:
self.cancelDownload()
self.removeEventObservers()
if self._loggingEnabled:
self._addOwnObservers()
def cancelDownload(self):
""" Cancels the download """
self._canceled = True
def wasCanceled(self):
""" Returns boolean value stating if download has been canceled
Returns:
bool: True if download was canceled. Otherwise False.
"""
return self._canceled
def downloadFileIntoCache(self, uri, name):
""" Downloads data from url into the local filesystem cache with the given filename
Params:
url(str): url to retrieve the data from
filename(str): filename of the downloaded data on the local filesystem
Returns:
filePath(str): path to the downloaded data on the local filesystem
"""
return self.downloadFile(uri, slicer.mrmlScene.GetCacheManager().GetRemoteCacheDirectory(), name)
def downloadFile(self, url, destinationDirectory, filename):
""" Downloads data from url into the given destination directory with the given filename
Params:
url(str): url to retrieve the data from
destinationDirectory(str): destination directory where to store the data on the local filesystem
filename(str): filename of the downloaded data on the local filesystem
Returns:
filePath(str): path to the downloaded data on the local filesystem
"""
if self.isDownloading:
self.cancelDownload()
self._canceled = False
filePath = os.path.join(destinationDirectory, filename)
if not os.path.exists(filePath) or os.stat(filePath).st_size == 0:
self.downloadPercent = 0
self.invokeEvent(self.StatusChangedEvent, str(['Requesting download %s from %s...' % (filename, url),
self.downloadPercent]))
try:
self.isDownloading = True
self.retrieve(url, filePath, self._reportHook)
self.invokeEvent(self.StatusChangedEvent, str(['Download finished', self.downloadPercent]))
except IOError as e:
self.invokeEvent(self.FailedEvent, str(['Download failed: %s' % e, self.downloadPercent]))
else:
self.invokeEvent(self.StatusChangedEvent, str(['File already exists in cache - reusing it.', 100]))
return filePath
def retrieve(self, url, filename=None, reporthook=None, data=None):
""" Retrieves data from the given url and returns a tuple of filename and headers
Args:
url (str): url of the data to be retrieved
filename (str, optional): filename from the url to download
reporthook: (function, optional): function that should be called for e.g. keeping an UI updated with current state
data (, optional):
Returns:
result: (filename, headers)
See Also:
urllib.URLopener
"""
self._canceled=False
url = urllib.unwrap(urllib.toBytes(url))
if self.tempcache and url in self.tempcache:
return self.tempcache[url]
type, url1 = urllib.splittype(url)
if filename is None and (not type or type == 'file'):
try:
fp = self.open_local_file(url1)
hdrs = fp.info()
fp.close()
return urllib.url2pathname(urllib.splithost(url1)[1]), hdrs
except IOError:
pass
fp = self.open(url, data)
try:
headers = fp.info()
if filename:
tfp = open(filename, 'wb')
else:
import tempfile
garbage, path = urllib.splittype(url)
garbage, path = urllib.splithost(path or "")
path, garbage = urllib.splitquery(path or "")
path, garbage = urllib.splitattr(path or "")
suffix = os.path.splitext(path)[1]
(fd, filename) = tempfile.mkstemp(suffix)
self.__tempfiles.append(filename)
tfp = os.fdopen(fd, 'wb')
try:
result = filename, headers
if self.tempcache is not None:
self.tempcache[url] = result
bs = 1024 * 8
size = -1
read = 0
blocknum = 0
if "content-length" in headers:
size = int(headers["Content-Length"])
if reporthook:
reporthook(blocknum, bs, size)
while not self._canceled:
block = fp.read(bs)
if block == "":
break
read += len(block)
tfp.write(block)
blocknum += 1
if reporthook:
reporthook(blocknum, bs, size)
finally:
tfp.close()
finally:
fp.close()
# raise exception if actual size does not match content-length header
if size >= 0 and read < size:
raise urllib.ContentTooShortError("retrieval incomplete: got only %i out "
"of %i bytes" % (read, size), result)
if self._canceled and os.path.exists(filename):
os.remove(filename)
return result
def _addOwnObservers(self):
for event in [self.StatusChangedEvent, self.CanceledEvent,
self.FailedEvent, self.FinishedEvent]:
self.addEventObserver(event, self._logMessage)
@vtk.calldata_type(vtk.VTK_STRING)
def _logMessage(self, caller, event, callData):
message, _ = ast.literal_eval(callData)
logging.debug(message)
def _humanReadableFormatSize(self, size):
""" See Also: from http://stackoverflow.com/questions/1094841/reusable-library-to-get-human-readable-version-of-file-size
"""
for x in ['bytes', 'KB', 'MB', 'GB']:
if -1024.0 < size < 1024.0:
return "%3.1f %s" % (size, x)
size /= 1024.0
return "%3.1f %s" % (size, 'TB')
def _reportHook(self, blocksSoFar, blockSize, totalSize):
percent = min(int((100. * blocksSoFar * blockSize) / totalSize), 100)
humanSizeSoFar = self._humanReadableFormatSize(min(blocksSoFar * blockSize, totalSize))
humanSizeTotal = self._humanReadableFormatSize(totalSize)
self.downloadPercent = percent
self.invokeEvent(self.StatusChangedEvent, str(['Downloaded %s (%d%% of %s)...' % (humanSizeSoFar, percent,
humanSizeTotal),
self.downloadPercent]))
class DirectoryObserver(ModuleLogicMixin):
""" Helper class for observing a given directory by checking the filecount every n milliseconds
Args:
directory(str): directory to be observed
every(int, optional): time in milliseconds defining how often to check the filecount
"""
@property
def running(self):
""" Returns if observation of directory is currently active
Returns:
bool: True if running else False
"""
return getattr(self, "_running", False)
StartedEvent = SlicerDevelopmentToolboxEvents.StartedEvent
""" Invoked when DirectoryObserver starts observing directory """
StoppedEvent = SlicerDevelopmentToolboxEvents.StoppedEvent
""" Invoked when DirectoryObserver stops observing directory """
FileCountChangedEvent = SlicerDevelopmentToolboxEvents.FileCountChangedEvent
""" Invoked when filecount of the observed directory changed """
def __init__(self, directory, every=1000):
self._directory = directory
self._every = every
self._setupTimer()
self.reset()
def __del__(self):
self.reset()
super(DirectoryObserver, self).__del__()
def reset(self):
""" Resets class members and stops DirectoryObserver if it is observing a directory """
self._initialFileList = []
self._currentFileList = []
self._currentStatus = ""
if self.running:
self.stop()
def isRunning(self):
""" Returns state if DirectoryObserver is observing
Returns:
bool: True if DirectoryObserver is currently observing a directory, otherwise False
"""
return self.running
def start(self):
""" Starts observing the directory and invokes StartedEvent """
self.stop()
self._initialFileList = self.getFileList(self._directory)
self._lastFileCount = len(self._initialFileList)
self._running = True
self._startObserving()
self.invokeEvent(self.StartedEvent)
def stop(self):
""" Stops observing the directory (if observing is currently running) and invokes StoppedEvent """
if self.running:
self.observingTimer.stop()
self._running = False
self.reset()
self.invokeEvent(self.StoppedEvent)
def _setupTimer(self):
self.observingTimer = self.createTimer(interval=self._every, slot=self._startObserving, singleShot=True)
def _startObserving(self):
if not self.running:
return
self._currentFileList = self.getFileList(self._directory)
currentFileListCount = len(self._currentFileList)
if self._lastFileCount != currentFileListCount:
self._onFileCountChanged(currentFileListCount)
else:
self._onFileCountUnchanged()
def _onFileCountUnchanged(self):
self.observingTimer.start()
def _onFileCountChanged(self, currentFileListCount):
self._lastFileCount = currentFileListCount
newFileCount = abs(len(self._initialFileList) - currentFileListCount)
self.invokeEvent(self.FileCountChangedEvent, newFileCount)
self.observingTimer.start()
class TimeoutDirectoryObserver(DirectoryObserver):
""" Observes a directory and fires event if filecount changed once and is unchanged for a period of time (timeout)
The observation timeout is useful when receiving DICOM data via storescp process since there is no sign of a finished
reception. One indicator for this can be the unchanged filecount for a period of time. The timeout defines a period
of time that TimeoutDirectoryObserver waits until it checks the filecount again and invokes the event in case it is
still unchanged.
Args:
directory(str): directory to be observed
timeout(str, optional): time in milliseconds Default is 5000
See Also:
:paramref:`SlicerDevelopmentToolboxUtils.helpers.DirectoryObserver`
"""
IncomingDataReceiveFinishedEvent = SlicerDevelopmentToolboxEvents.FinishedEvent
""" Invoked after timeout exceeded and filecount is unchanged for the time of timeout """
def __init__(self, directory, timeout=5000):
self.receiveFinishedTimeout = timeout
super(TimeoutDirectoryObserver, self).__init__(directory)
def _setupTimer(self):
super(TimeoutDirectoryObserver, self)._setupTimer()
self._timeoutTimer = self.createTimer(interval=5000, slot=self._checkIfStillSameFileCount, singleShot=True)
def stop(self):
if self.running:
self._timeoutTimer.stop()
super(TimeoutDirectoryObserver, self).stop()
def _onFileCountUnchanged(self):
currentFileListCount = len(self._currentFileList)
if currentFileListCount != len(self._initialFileList):
self._lastFileCount = currentFileListCount
self._timeoutTimer.start()
else:
self.observingTimer.start()
def _checkIfStillSameFileCount(self):
self._currentFileList = self.getFileList(self._directory)
if self._lastFileCount == len(self._currentFileList):
newFileList = list(set(self._currentFileList) - set(self._initialFileList))
self._initialFileList = self._currentFileList
self._lastFileCount = len(self._initialFileList)
if len(newFileList):
self.invokeEvent(self.IncomingDataReceiveFinishedEvent, str(newFileList))
self.observingTimer.start()
class SmartDICOMReceiver(ModuleLogicMixin):
""" SmartDICOMReceiver combines storescp with an observation of changes within the destination directory
Since storescp is not giving any feedback about a finished transfer, SmartDICOMReceiver combines storescp with the
observation process provided by the TimeoutDirectoryObserver. By using a timeout, SmartDICOMReceiver knows when a
transfer is finished unless there are other reasons for a failed transfer.
Args:
destinationDirectory(str): destination directory for reception of DICOM images
incomingPort(str or int, optional): port on which incoming date is expected to get received Default port is 11112
.. code-block:: python
import os
import vtk
import shutil
from SlicerDevelopmentToolboxUtils.mixins import ModuleLogicMixin
from SlicerDevelopmentToolboxUtils.helpers import SmartDICOMReceiver
@vtk.calldata_type(vtk.VTK_INT)
def onFileCountChanged(caller, event, callData):
print "Received %d files" % callData
inputPath = os.path.join(slicer.app.temporaryPath, "SmartDICOMReceiverTest")
ModuleLogicMixin.createDirectory(inputPath)
dicomReceiver = SmartDICOMReceiver(inputPath, incomingPort=11112)
dicomReceiver.addEventObserver(dicomReceiver.FileCountChangedEvent, onFileCountChanged)
dicomReceiver.start()
# then send some data....
dicomReceiver.stop()
shutil.rmtree(inputPath)
"""
_NAME = "SmartDICOMReceiver"
_STATUS_RECEIVING = "{}: Receiving DICOM data".format(_NAME)
_STATUS_WAITING = "{}: Waiting for incoming DICOM data".format(_NAME)
_STATUS_WAITING_WITHOUT_STORE_SCP = "{}: Watching incoming data directory only (no storescp running)".format(_NAME)
_STATUS_STOPPED = "{}: Stopped DICOM receiver".format(_NAME)
StatusChangedEvent = SlicerDevelopmentToolboxEvents.StatusChangedEvent
""" Invoked whenever status is updated """
StartedEvent = SlicerDevelopmentToolboxEvents.StartedEvent
""" Invoked after SmartDICOMReceiver is started (with or without storescp) """
StoppedEvent = SlicerDevelopmentToolboxEvents.StoppedEvent
""" Invoked after SmartDICOMReceiver is stopped """
IncomingDataReceiveFinishedEvent = TimeoutDirectoryObserver.IncomingDataReceiveFinishedEvent
""" Invoked when DICOM images has been received """
FileCountChangedEvent = TimeoutDirectoryObserver.FileCountChangedEvent
""" Invoked when filecount of the destination directory changed """
def __init__(self, destinationDirectory, incomingPort=None):
self.destinationDirectory = destinationDirectory
self._directoryObserver = TimeoutDirectoryObserver(destinationDirectory)
self._connectEvents()
self._storeSCPProcess = None
self._incomingPort = None if not incomingPort else int(incomingPort)
self._running = False
self.currentStatus = ""
slicer.app.connect('aboutToQuit()', self.stop)
def __del__(self):
self.stop()
super(SmartDICOMReceiver, self).__del__()
def isRunning(self):
""" Returns state if SmartDICOMReceiver is currently running
Returns:
bool: True if SmartDICOMReceiver is currently running, otherwise False
"""
return self._running
def start(self, runStoreSCP=True):
""" Starts observation process of the destination directory and storescp if specified and invokes StartedEvent
Args:
runStoreSCP(bool,optional): specifies if storescp process should be started. Default value is set to True
"""
self.stop()
self._directoryObserver.start()
if runStoreSCP:
self._startStoreSCP()
self.invokeEvent(self.StartedEvent)
self._running = True
self._refreshCurrentStatus()
def stop(self):
""" Stops observation and storescp process and invokes StoppedEvent """
if self._running:
self._directoryObserver.stop()
self.stopStoreSCP()
self._updateStatus(self._STATUS_STOPPED)
self.invokeEvent(self.StoppedEvent)
def stopStoreSCP(self):
""" Stopping the storescp process only without stopping the observation process """
if self._storeSCPProcess:
self._storeSCPProcess.stop()
self._storeSCPProcess = None
def forceStatusChangeEventUpdate(self):
""" Forces a current status update to be invoked with the current status """
self.currentStatus = "Force update"
self._refreshCurrentStatus()
def _startStoreSCP(self):
self.stopStoreSCP()
self._storeSCPProcess = DICOMStoreSCPProcess(incomingDataDir=self.destinationDirectory,
incomingPort=self._incomingPort)
self._storeSCPProcess.start()
def _connectEvents(self):
self._directoryObserver.addEventObserver(self.IncomingDataReceiveFinishedEvent, self._onDataReceptionFinished)
self._directoryObserver.addEventObserver(self.FileCountChangedEvent, self._onFileCountChanged)
@vtk.calldata_type(vtk.VTK_STRING)
def _onDataReceptionFinished(self, caller, event, callData):
self._updateStatus("{}: DICOM data receive completed.".format(self._NAME))
self.invokeEvent(self.IncomingDataReceiveFinishedEvent, callData)
@vtk.calldata_type(vtk.VTK_INT)
def _onFileCountChanged(self, caller, event, callData):
status = "{}: Received {} files".format(self._NAME, callData)
self._updateStatus(status)
self.invokeEvent(self.FileCountChangedEvent, callData)
def _updateStatus(self, text):
if text != self.currentStatus:
self.currentStatus = text
self.invokeEvent(self.StatusChangedEvent, text)
def _refreshCurrentStatus(self):
statusText = ""
if self._running:
statusText = self._STATUS_WAITING if self._storeSCPProcess else self._STATUS_WAITING_WITHOUT_STORE_SCP
self._updateStatus(statusText)
class SliceAnnotationHandlerBase(ModuleWidgetMixin):
""" Base class for handling slice annotations for different situation (e.g. steps)
Holds all slice annotations and keeps track of removing them all when requested. Method addSliceAnnotations needs to
be implemented.
"""
def __init__(self):
self.sliceAnnotations = []
self._setupSliceWidgets()
def cleanup(self):
""" Removes slice annotations """
self.removeSliceAnnotations()
def _setupSliceWidgets(self):
self.createSliceWidgetClassMembers("Red")
self.createSliceWidgetClassMembers("Yellow")
self.createSliceWidgetClassMembers("Green")
def addSliceAnnotations(self):
""" Keeps track of adding slice annotations at the right time (e.g. different layouts - different annotations)
Note:
This method must be implemented by inheriting classes
"""
raise NotImplementedError
def removeSliceAnnotations(self):
while len(self.sliceAnnotations):
annotation = self.sliceAnnotations.pop()
annotation.remove()
class SliceAnnotation(object):
""" Represents a text to a slice widget/view.
Besides defining which text should be displayed within the slice widget at which position a variety of other
properties can be defined listed as keyword arguments.
Note: The annotation is automatically resized if it doesn't fit into the slice widget.
Args:
widget(qMRMLSliceWidget): slice widget to show text on
text(str): text to display on slice widget
:Keyword Arguments:
* *xPos* (``int``)
* *yPos* (``int``)
* *size* (``int``) -- Default: 20
* *color* (``tuple``) -- rgb color. Default: (1.0, 0.0 ,0.0)
* *bold* (``int``) -- Default: 1
* *shadow* (``int``) -- Default: 1
* *opacity* (``float``) -- Default: 1.0
* *verticalAlign* (``str``) -- one of POSSIBLE_VERTICAL_ALIGN. Default: "center"
* *horizontalAlign* (``str``) -- one of POSSIBLE_HORIZONTAL_ALIGN. Default: "center"
.. code-block:: python
from SlicerDevelopmentToolboxUtils.helpers import SliceAnnotation
kwargs = {"yPos":55, "size":30}
redWidget = slicer.app.layoutManager().sliceWidget("Red")
text = "Testing the display of annotations"
annotation = SliceAnnotation(redWidget, text, **kwargs)
annotation.size = 50
# then try
annotation.hide()
"""
ALIGN_LEFT = "left"
""" Alignment left """
ALIGN_CENTER = "center"
""" Alignment center """
ALIGN_RIGHT = "right"
""" Alignment right """
ALIGN_TOP = "top"
""" Alignment top """
ALIGN_BOTTOM = "bottom"
""" Alignment bottom """
POSSIBLE_VERTICAL_ALIGN = [ALIGN_TOP, ALIGN_CENTER, ALIGN_BOTTOM]
POSSIBLE_HORIZONTAL_ALIGN = [ALIGN_LEFT, ALIGN_CENTER, ALIGN_RIGHT]
@property
def size(self):
""" Font size of the text """
return self._size
@size.setter
def size(self, size):
self._initialSize = size
self._size = size
self._update()
@property
def textProperty(self):
""" vtk.vtkTextProperty presenting properties for the text to be displayed"""
if not self.textActor:
return None
return self.textActor.GetTextProperty()
@textProperty.setter
def textProperty(self, textProperty):
assert issubclass(textProperty, vtk.vtkTextProperty)
self.textActor.SetTextProperty(textProperty)
self._update()
@property
def opacity(self):
""" Text opacity """
if self.textProperty:
return self.textProperty.GetOpacity()
return None
@opacity.setter
def opacity(self, value):
if not self.textProperty:
return
self.textProperty.SetOpacity(value)
self._update()
@property
def color(self):
""" Text color """
if self.textProperty:
return self.textProperty.GetColor()
@color.setter
def color(self, value):
assert type(value) is tuple and len(value) == 3
if self.textProperty:
self.textProperty.SetColor(value)
self._update()
@property
def verticalAlign(self):
""" Vertical align """
return self._verticalAlign
@verticalAlign.setter
def verticalAlign(self, value):
if value not in self.POSSIBLE_VERTICAL_ALIGN:
raise ValueError("Value %s is not allowed for vertical alignment. Only the following values are allowed: %s"
% (str(value), str(self.POSSIBLE_VERTICAL_ALIGN)))
else:
self._verticalAlign = value
@property
def horizontalAlign(self):
""" Horizontal Align"""
return self._horizontalAlign
@horizontalAlign.setter
def horizontalAlign(self, value):
if value not in self.POSSIBLE_HORIZONTAL_ALIGN:
raise ValueError("Value %s is not allowed for horizontal alignment. Only the following values are allowed: %s"
% (str(value), str(self.POSSIBLE_HORIZONTAL_ALIGN)))
else:
self._horizontalAlign = value
@property
def _renderer(self):
return self.sliceView.renderWindow().GetRenderers().GetItemAsObject(0)
def __init__(self, widget, text, **kwargs):
self.observer = None
self.textActor = None
self.text = text
self.sliceWidget = widget
self.sliceView = widget.sliceView()
self.sliceLogic = widget.sliceLogic()
self.sliceNode = self.sliceLogic.GetSliceNode()
self.sliceNodeDimensions = self.sliceNode.GetDimensions()
self.xPos = kwargs.pop('xPos', 0)
self.yPos = kwargs.pop('yPos', 0)
self._initialSize = kwargs.pop('size', 20)
self._size = self._initialSize
self.textColor = kwargs.pop('color', (1.0, 0.0, 0.0))
self.textBold = kwargs.pop('bold', 1)
self.textShadow = kwargs.pop('shadow', 1)
self.textOpacity = kwargs.pop('opacity', 1.0)
self.verticalAlign = kwargs.pop('verticalAlign', 'center')
self.horizontalAlign = kwargs.pop('horizontalAlign', 'center')
self.shadowOffset = kwargs.pop('shadowOffset', (1,2))
self._createTextActor()
def __del__(self):
self.remove()
def show(self):
""" Displays the text within the slice widget """
self._addActor()
self._addObserver()
self._update()
def hide(self):
""" Hides the text from the slice widget """
self.remove()
def remove(self):
""" Hides the text from the slice widget """
self._removeObserver()
self._removeActor()
self._update()
def _addObserver(self):
if not self.observer and self.sliceNode:
self.observer = self.sliceNode.AddObserver(vtk.vtkCommand.ModifiedEvent, self._onModified)
def _removeObserver(self):
if self.observer:
self.sliceNode.RemoveObserver(self.observer)
self.observer = None
def _removeActor(self):
try:
self._renderer.RemoveActor(self.textActor)
self._update()
except:
pass
def _addActor(self):
self._renderer.AddActor(self.textActor)
self._update()
def _update(self):
if not self._fitIntoViewport(self._size):
logging.debug("Font size is to large for slice widget. Decreasing.")
self._decreaseSizeToFitViewport()
self._applyPositioning()
self.sliceView.update()
def _createTextActor(self):
self.textActor = vtk.vtkTextActor()
self.textActor.SetInput(self.text)
self.textProperty.SetColor(self.textColor)
self.textProperty.SetBold(self.textBold)
self.textProperty.SetShadow(self.textShadow)
self.textProperty.SetShadowOffset(self.shadowOffset)
self.textProperty.SetOpacity(self.textOpacity)
self.textActor.SetTextProperty(self.textProperty)
self.size = self._initialSize
self.show()
def _applyPositioning(self):
xPos = self._applyHorizontalAlign()
yPos = self._applyVerticalAlign()
self.textActor.SetDisplayPosition(xPos, yPos)
def _applyHorizontalAlign(self):
sliceViewWidth = self.sliceView.width if ModuleWidgetMixin.isQtVersionOlder() else \
self.sliceView.width * self.sliceView.devicePixelRatio()
centerX = int((sliceViewWidth - self._getFontWidth()) / 2)
if self.xPos:
xPos = self.xPos if 0 < self.xPos < centerX else centerX
else:
if self.horizontalAlign == self.ALIGN_LEFT:
xPos = 0
elif self.horizontalAlign == self.ALIGN_CENTER:
xPos = centerX
elif self.horizontalAlign == self.ALIGN_RIGHT:
xPos = sliceViewWidth - self._getFontWidth()
return int(xPos)
def _applyVerticalAlign(self):
sliceViewHeight = self.sliceView.height if ModuleWidgetMixin.isQtVersionOlder() else \
self.sliceView.height * self.sliceView.devicePixelRatio()
centerY = int((sliceViewHeight - self._getFontHeight()) / 2)
if self.yPos:
yPos = self.yPos if 0 < self.yPos < centerY else centerY
else:
if self.verticalAlign == self.ALIGN_TOP:
yPos = sliceViewHeight - self._getFontHeight()
elif self.verticalAlign == self.ALIGN_CENTER:
yPos = centerY
elif self.verticalAlign == self.ALIGN_BOTTOM:
yPos = 0
return int(yPos)
def _onModified(self, caller, event):
if event != "ModifiedEvent":
return
currentDimensions = caller.GetDimensions()
if currentDimensions != self.sliceNodeDimensions:
self._increaseSizeToFitViewport()
self._update()
self.sliceNodeDimensions = currentDimensions
def _getFontWidth(self):
return self._getFontDimensions()[0]
def _getFontHeight(self):
return self._getFontDimensions()[1]
def _getFontDimensions(self):
size = [0.0, 0.0]
self.textActor.GetSize(self._renderer, size)
return size
def _fitIntoViewport(self, size):
tempSize = self.textProperty.GetFontSize()
self.textProperty.SetFontSize(size)
self.textActor.SetTextProperty(self.textProperty)
if self._getFontWidth() > (self.sliceView.width if ModuleWidgetMixin.isQtVersionOlder() else \
self.sliceView.width * self.sliceView.devicePixelRatio()):
self.textProperty.SetFontSize(tempSize)
self.textActor.SetTextProperty(self.textProperty)
return False
return True
def _decreaseSizeToFitViewport(self):
while not self._fitIntoViewport(self._size):
self._size -= 1
def _increaseSizeToFitViewport(self):
while self._fitIntoViewport(self._size) and self._size < self._initialSize:
self._size += 1
class DICOMDirectorySender(DICOMProcess):
""" Send files/directories to a remote host (uses storescu from dcmtk)
Args:
directory(str): source directory to send data from
address(str): destination address to send the data to
port(int): destination port to send the data to
progressCallback(function, optional): function that takes a string parameter. Default is None
.. code-block:: python
from SlicerDevelopmentToolboxUtils.helpers import SliceAnnotation
source = #any directory
dicomSender = DICOMDirectorySender(directory=source, address='localhost', port=11112)
dicomSender.send()
"""
_STORESCU_PROCESS_FILE_NAME = "storescu"
def __init__(self, directory, address, port, progressCallback=None):
super(DICOMDirectorySender, self).__init__()
self.directory = directory
self.address = address
self.port = port
self.progressCallback = progressCallback
if not self.progressCallback:
self.progressCallback = self._defaultProgressCallback
self.send()
self.storescuExecutable = os.path.join(self.exeDir, self._STORESCU_PROCESS_FILE_NAME + self.exeExtension)
def __del__(self):
super(DICOMDirectorySender,self).__del__()
def onStateChanged(self, newState):
stdout, stderr = super(DICOMDirectorySender, self).onStateChanged(newState)
if stderr and stderr.size():
slicer.util.errorDisplay("An error occurred. For further information click 'Show Details...'",
windowTitle=self.__class__.__name__, detailedText=str(stderr))
return stdout, stderr
def send(self):
""" Starts the sending process """
self.progressCallback("Starting send to %s:%s" % (self.address, self.port))
self.start()
self.progressCallback("Sent %s to %s:%s" % (self.directory, self.address, self.port))
def start(self, cmd=None, args=None):
""" Starts storescup executable """
self.storeSCUExecutable = os.path.join(self.exeDir, 'storescu'+self.exeExtension)
# TODO: check pattern,,, .DS_Store exclusion
args = [str(self.address), str(self.port), "-aec", "CTK", "--scan-directories", "--recurse", "--scan-pattern" ,
"*[0-9a-Z]", self.directory]
super(DICOMDirectorySender,self).start(self.storeSCUExecutable, args)
self.process.connect('readyReadStandardOutput()', self._readFromStandardOutput)
def _defaultProgressCallback(self, s):
print(s)
def _readFromStandardOutput(self, readLineCallback=None):
print('================ready to read stdout from %s===================' % self.__class__.__name__)
while self.process.canReadLine():
line = str(self.process.readLine())
print("From %s: %s" % (self.__class__.__name__, line))
if readLineCallback:
readLineCallback(line)
print('================end reading stdout from %s===================' % self.__class__.__name__)
self._readFromStandardError()
def _readFromStandardError(self):
stdErr = str(self.process.readAllStandardError())
if stdErr:
print('================ready to read stderr from %s===================' % self.__class__.__name__)
print ("processed stderr: %s" %stdErr)
print('================end reading stderr from %s===================' % self.__class__.__name__)
class WatchBoxAttribute(object):
"""" A data structure for holding attribute information for displaying it within a BasicInformationWatchBox
Class members tags (e.g. xml or DICOM) and callback are helpful for file based watch boxes
Args:
name(str): Name of the attribute
title(str): Title to be displayed for the attribute
tags(str or list(str), optional): Tags to retrieve information from i.e. when XML or DICOM is used as source
masked(bool, optional): Enables the option to mask the displayed value for the attribute. Default is False
callback(function, optional): Callback to retrieve the actual value from. Default is None
See Also:
:paramref:`SlicerDevelopmentToolboxUtils.widgets.BasicInformationWatchBox`
:paramref:`SlicerDevelopmentToolboxUtils.widgets.FileBasedInformationWatchBox`
:paramref:`SlicerDevelopmentToolboxUtils.widgets.XMLBasedInformationWatchBox`
:paramref:`SlicerDevelopmentToolboxUtils.widgets.DICOMBasedInformationWatchBox`
"""
MASKED_PLACEHOLDER = "X"
""" Placeholder to display when masking is enabled to hide confidential information """
TRUNCATE_LENGTH = None
""" Maximum length a text should have. In case it's longer it will be truncated """
@property
def title(self):
""" Title of the attribute to be displayed """
return self.titleLabel.text
@title.setter
def title(self, value):
self.titleLabel.text = value if value else ""
@property
def masked(self):
""" Returns if masking is enabled."""
return self._masked
@masked.setter
def masked(self, value):
if self._masked == value:
return
self._masked = value
self.updateVisibleValues(self.originalValue if not self.masked else self.maskedValue(self.originalValue))
@property
def value(self):
""" Value of the attribute to be displayed.
Note:
This value can be masked
"""
return self.valueLabel.text
@value.setter
def value(self, value):
if not value:
value = ""
if type(value) not in [str]:
value = str(value)
self.originalValue = value
self.updateVisibleValues(self.originalValue if not self.masked else self.maskedValue(self.originalValue))
@property
def originalValue(self):
""" Original value of the attribute """
return self._value
@originalValue.setter
def originalValue(self, value):
self._value = value
def __init__(self, name, title, tags=None, masked=False, callback=None):
self.name = name
self._masked = masked
self.titleLabel = qt.QLabel()
self.titleLabel.setStyleSheet("QLabel{ font-weight: bold;}")
self.valueLabel = qt.QLabel()
self.title = title
self.callback = callback
self.tags = None if not tags else tags if type(tags) is list else [str(tags)]
self.value = None
def updateVisibleValues(self, value):
""" Updates the v"""
self.valueLabel.text = value[0:self.TRUNCATE_LENGTH]+"..." if self.TRUNCATE_LENGTH and \
len(value) > self.TRUNCATE_LENGTH else value
self.valueLabel.toolTip = value
def maskedValue(self, value):
""" Replacing the original value for displaying with MASKED_PLACEHOLDER
Args:
value(str): value that should get masked and returned
Returns:
str:
"""
return self.MASKED_PLACEHOLDER * len(value)
| {"/SlicerDevelopmentToolboxUtils/buttons.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/widgets.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/helpers.py": ["/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/widgets.py": ["/SlicerDevelopmentToolboxUtils/constants.py", "/SlicerDevelopmentToolboxUtils/decorators.py", "/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/helpers.py", "/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/module/logic.py": ["/SlicerDevelopmentToolboxUtils/module/base.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py": ["/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py"], "/SlicerDevelopmentToolboxUtils/module/plugin.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/step.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/session.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/icons.py": ["/SlicerDevelopmentToolboxUtils/decorators.py"], "/SlicerDevelopmentToolboxUtils/forms/FormsDialog.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py"], "/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGenerator.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/module/base.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/decorators.py"]} |
50,121 | QIICR/SlicerDevelopmentToolbox | refs/heads/master | /SlicerDevelopmentToolboxUtils/widgets.py | import datetime
import logging
import os
import xml.dom
import ctk
import qt
import slicer
import vtk
from SlicerDevelopmentToolboxUtils.constants import DICOMTAGS
from SlicerDevelopmentToolboxUtils.decorators import singleton
from SlicerDevelopmentToolboxUtils.events import SlicerDevelopmentToolboxEvents
from SlicerDevelopmentToolboxUtils.helpers import SmartDICOMReceiver, DICOMDirectorySender
from SlicerDevelopmentToolboxUtils.mixins import ModuleWidgetMixin, ModuleLogicMixin, ParameterNodeObservationMixin
from SlicerDevelopmentToolboxUtils.icons import Icons
@singleton
class CustomStatusProgressbar(qt.QWidget):
STYLE = "QWidget{background-color:#FFFFFF;}"
@property
def text(self):
return self.textLabel.text
@text.setter
def text(self, value):
self.textLabel.text = value
@property
def value(self):
return self.progress.value
@value.setter
def value(self, value):
self.progress.value = value
self.refreshProgressVisibility()
@property
def maximum(self):
return self.progress.maximum
@maximum.setter
def maximum(self, value):
self.progress.maximum = value
self.refreshProgressVisibility()
@property
def busy(self):
return self.progress.minimum == 0 and self.progress.maximum == 0
@busy.setter
def busy(self, busy):
if busy:
if not (self.progress.minimum == 0 and self.progress.maximum == 0):
self._oldMinimum = self.progress.minimum
self._oldMaximum = self.progress.maximum
self.progress.maximum = self.progress.minimum = 0
else:
self.progress.minimum = getattr(self, "_oldMinimum", 0)
self.progress.maximum = getattr(self, "_oldMaximum", 100)
self.refreshProgressVisibility()
def __init__(self, parent=None, **kwargs):
qt.QWidget.__init__(self, parent, **kwargs)
self.setup()
self.reset()
def setup(self):
self.textLabel = qt.QLabel()
self.progress = qt.QProgressBar()
if slicer.util.mainWindow():
self.maximumHeight = slicer.util.mainWindow().statusBar().height
rowLayout = qt.QHBoxLayout()
self.setLayout(rowLayout)
rowLayout.addWidget(self.textLabel, 1)
rowLayout.addWidget(self.progress, 1)
self.setStyleSheet(self.STYLE)
self.refreshProgressVisibility()
if not self.parent() and slicer.util.mainWindow():
slicer.util.mainWindow().statusBar().addWidget(self, 1)
def updateStatus(self, text, value=None):
self.text = text
if value is not None:
self.value = value
def reset(self):
self.text = ""
self.progress.reset()
self.progress.maximum = 100
self.refreshProgressVisibility()
def refreshProgressVisibility(self):
self.progress.visible = self.value > 0 and self.progress.maximum > 0 or self.progress.maximum == 0
class TargetCreationWidget(qt.QWidget, ModuleWidgetMixin):
""" TargetCreationWidget is an exclusive QWidget for creating targets/fiducials
.. image:: images/TargetCreationWidget.gif
Args:
parent (qt.QWidget, optional): parent of the widget
.. doctest::
import ast
import vtk
@vtk.calldata_type(vtk.VTK_STRING)
def onTargetSelected(caller, event, callData):
info = ast.literal_eval(callData)
node = slicer.mrmlScene.GetNodeByID(info["nodeID"])
index = info["index"]
print "%s clicked" % node.GetNthFiducialLabel(index)
from SlicerDevelopmentToolboxUtils.widgets import TargetCreationWidget
t = TargetCreationWidget()
t.targetListSelectorVisible = True
t.addEventObserver(t.TargetSelectedEvent, onTargetSelected)
t.show()
"""
_HEADERS = ["Name", "Delete"]
DEFAULT_FIDUCIAL_LIST_NAME = None
""" Default fiducial list name to be used """
DEFAULT_CREATE_FIDUCIALS_TEXT = "Place Target(s)"
""" Default text to be displayed for the startTargetingButton """
DEFAULT_MODIFY_FIDUCIALS_TEXT = "Modify Target(s)"
""" Default text to be displayed after creation for the startTargetingButton """
StartedEvent = SlicerDevelopmentToolboxEvents.StartedEvent
""" Targeting mode was activated"""
FinishedEvent = SlicerDevelopmentToolboxEvents.FinishedEvent
""" Targeting was finished """
TargetSelectedEvent = vtk.vtkCommand.UserEvent + 337
""" Target selection changed
Slot to be called once
.. doctest::
import ast
import vtk
@vtk.calldata_type(vtk.VTK_STRING)
def onTargetSelected(caller, event, callData):
info = ast.literal_eval(callData)
print info["index"]
print info["nodeID"]
"""
@property
def currentNode(self):
""" Property for getting/setting current vtkMRMLMarkupsFiducialNode.
currentNode represents the vtkMRMLMarkupsFiducialNode which is used for displaying/creating fiducials/targets.
"""
return self.targetListSelector.currentNode()
@currentNode.setter
def currentNode(self, node):
if self._currentNode:
self.stopPlacing()
self._removeTargetListObservers()
self.targetListSelector.setCurrentNode(node)
self._currentNode = node
if node:
self._addTargetListObservers()
self._selectionNode.SetReferenceActivePlaceNodeID(node.GetID())
else:
self._selectionNode.SetReferenceActivePlaceNodeID(None)
self._updateButtons()
self._updateTable()
@property
def targetListSelectorVisible(self):
""" Property for changing visibility of target list selector """
return self.targetListSelectorArea.visible
@targetListSelectorVisible.setter
def targetListSelectorVisible(self, visible):
self.targetListSelectorArea.visible = visible
def __init__(self, parent=None, **kwargs):
qt.QWidget.__init__(self, parent)
self._processKwargs(**kwargs)
self._connectedButtons = []
self._modifiedEventObserverTag = None
self._selectionNode = slicer.app.applicationLogic().GetSelectionNode()
self._selectionNode.SetReferenceActivePlaceNodeClassName("vtkMRMLMarkupsFiducialNode")
self._interactionNode = slicer.app.applicationLogic().GetInteractionNode()
self._setupIcons()
self._setup()
self._currentNode = None
def reset(self):
""" exits the fiducial/target placement mode and sets the currently observed vtkMRMLMarkupsFiducialNode to None
"""
self.stopPlacing()
self.currentNode = None
def startPlacing(self):
""" Enters the fiducial/target placement mode. """
if not self.currentNode:
self._createNewFiducialNode(name=self.DEFAULT_FIDUCIAL_LIST_NAME)
self._selectionNode.SetActivePlaceNodeID(self.currentNode.GetID())
self._interactionNode.SetPlaceModePersistence(1)
self._interactionNode.SetCurrentInteractionMode(self._interactionNode.Place)
def stopPlacing(self):
""" Exits the fiducial/target placement mode.
"""
self._interactionNode.SetCurrentInteractionMode(self._interactionNode.ViewTransform)
def getOrCreateFiducialNode(self):
""" Convenience method for getting (or creating if it doesn't exist) current vtkMRMLMarkupsFiducialNode"""
if not self.currentNode:
self.currentNode = self.targetListSelector.addNode()
return self.currentNode
def hasTargetListAtLeastOneTarget(self):
""" Returns if currently observed vtkMRMLMarkupsFiducialNode has at least one fiducial
Returns:
bool: True if vtkMRMLMarkupsFiducialNode is not None and number of fiducials in vtkMRMLMarkupsFiducialNode is
unequal zero, False otherwise
"""
return self.currentNode is not None and self.currentNode.GetNumberOfFiducials() > 0
def _setupIcons(self):
self._iconSize = qt.QSize(24, 24)
self.addTargetsIcon = Icons.fiducial_add
self.modifyTargetsIcon = Icons.fiducial_modify
self.finishTargetingIcon = Icons.apply
def _setup(self):
self.setLayout(qt.QGridLayout())
self._setupTargetFiducialListSelector()
self._setupTargetTable()
self._setupButtons()
self._setupConnections()
def _setupTargetFiducialListSelector(self):
self.targetListSelector = self.createComboBox(nodeTypes=["vtkMRMLMarkupsFiducialNode", ""], addEnabled=True,
removeEnabled=True, noneEnabled=True, showChildNodeTypes=False,
renameEnabled=True, selectNodeUponCreation=True,
toolTip="Select target list")
self.targetListSelectorArea = self.createHLayout([qt.QLabel("Target List: "), self.targetListSelector])
self.targetListSelectorArea.hide()
self.layout().addWidget(self.targetListSelectorArea)
def _setupTargetTable(self):
self.table = qt.QTableWidget(0, 2)
self.table.setSelectionBehavior(qt.QAbstractItemView.SelectRows)
self.table.setSelectionMode(qt.QAbstractItemView.SingleSelection)
self.table.setMaximumHeight(200)
method = getattr(self.table.horizontalHeader(),
"setResizeMode" if ModuleWidgetMixin.isQtVersionOlder() else "setSectionResizeMode")
method(qt.QHeaderView.Stretch)
method(0, qt.QHeaderView.Stretch)
method(1, qt.QHeaderView.ResizeToContents)
self._resetTable()
self.layout().addWidget(self.table)
def _setupButtons(self):
self.startTargetingButton = self.createButton("", enabled=True, icon=self.addTargetsIcon, iconSize=self._iconSize,
toolTip="Start placing targets")
self.stopTargetingButton = self.createButton("", enabled=False, icon=self.finishTargetingIcon, iconSize=self._iconSize,
toolTip="Finish placing targets")
self.buttons = self.createHLayout([self.startTargetingButton, self.stopTargetingButton])
self.layout().addWidget(self.buttons)
def _setupConnections(self):
self.startTargetingButton.clicked.connect(self.startPlacing)
self.stopTargetingButton.clicked.connect(self.stopPlacing)
self.interactionNodeObserver = self._interactionNode.AddObserver(self._interactionNode.InteractionModeChangedEvent,
self._onInteractionModeChanged)
self.targetListSelector.connect("currentNodeChanged(vtkMRMLNode*)", self._onFiducialListSelected)
self.table.connect("cellChanged(int,int)", self._onCellChanged)
self.table.connect('clicked(QModelIndex)', self._onTargetSelectionChanged)
self.table.selectionModel().currentRowChanged.connect(self._onTargetSelectionChanged)
def _onTargetSelectionChanged(self, current, prev=None):
row = current.row()
if not self.currentNode or row == -1:
return
self.invokeEvent(self.TargetSelectedEvent, str({"nodeID": self.currentNode.GetID(),
"index": row}))
def _onInteractionModeChanged(self, caller, event):
if not self.currentNode:
return
if self._selectionNode.GetActivePlaceNodeID() == self.currentNode.GetID():
interactionMode = self._interactionNode.GetCurrentInteractionMode()
self.invokeEvent(self.StartedEvent if interactionMode == self._interactionNode.Place else
self.FinishedEvent)
self._updateButtons()
def _onFiducialListSelected(self, node):
self.currentNode = node
def _createNewFiducialNode(self, name=None):
markupsLogic = slicer.modules.markups.logic()
self.currentNode = slicer.mrmlScene.GetNodeByID(markupsLogic.AddNewFiducialNode())
self.currentNode.SetName(name if name else self.currentNode.GetName())
def _cleanupButtons(self):
for button in self._connectedButtons:
button.clicked.disconnect(self._handleDeleteButtonClicked)
self._connectedButtons = []
def _removeTargetListObservers(self):
if self.currentNode and self._modifiedEventObserverTag:
self._modifiedEventObserverTag = self.currentNode.RemoveObserver(self._modifiedEventObserverTag)
def _addTargetListObservers(self):
self._removeTargetListObservers()
if self.currentNode:
self._modifiedEventObserverTag = self.currentNode.AddObserver(vtk.vtkCommand.ModifiedEvent, self._onFiducialsUpdated)
def _updateButtons(self):
if not self.currentNode or self.currentNode.GetNumberOfFiducials() == 0:
self.startTargetingButton.icon = self.addTargetsIcon
self.startTargetingButton.toolTip = "Place Target(s)"
else:
self.startTargetingButton.icon = self.modifyTargetsIcon
self.startTargetingButton.toolTip = "Modify Target(s)"
interactionMode = self._interactionNode.GetCurrentInteractionMode()
self.startTargetingButton.enabled = not interactionMode == self._interactionNode.Place
self.stopTargetingButton.enabled = interactionMode == self._interactionNode.Place
def _updateTable(self):
self._resetTable()
if not self.currentNode:
return
nOfControlPoints = self.currentNode.GetNumberOfFiducials()
if self.table.rowCount != nOfControlPoints:
self.table.setRowCount(nOfControlPoints)
for i in range(nOfControlPoints):
label = self.currentNode.GetNthFiducialLabel(i)
cellLabel = qt.QTableWidgetItem(label)
self.table.setItem(i, 0, cellLabel)
self._addDeleteButton(i, 1)
def _resetTable(self):
self._cleanupButtons()
self.table.setRowCount(0)
self.table.clear()
self.table.setHorizontalHeaderLabels(self._HEADERS)
def _addDeleteButton(self, row, col):
button = qt.QPushButton('X')
self.table.setCellWidget(row, col, button)
button.clicked.connect(lambda: self._handleDeleteButtonClicked(row))
self._connectedButtons.append(button)
def _handleDeleteButtonClicked(self, idx):
if slicer.util.confirmYesNoDisplay("Do you really want to delete target %s?"
% self.currentNode.GetNthFiducialLabel(idx)):
self.currentNode.RemoveMarkup(idx)
def _onFiducialsUpdated(self, caller, event):
if caller.IsA("vtkMRMLMarkupsFiducialNode") and event == "ModifiedEvent":
self._updateTable()
self._updateButtons()
self.invokeEvent(vtk.vtkCommand.ModifiedEvent)
def _onCellChanged(self, row, col):
if col == 0:
self.currentNode.SetNthFiducialLabel(row, self.table.item(row, col).text())
class SettingsMessageBox(qt.QMessageBox, ModuleWidgetMixin):
""" QMessageBox for displaying qt.QSettings defined for module 'moduleName'.
Normally Settings are defined in groups e.g. DICOM/{subgroup(optional)}/{settingsName}
.. image:: images/SettingsMessageBox.png
:width: 50%
Args:
moduleNames (list, optional):
name of the module(s) which qt.QSettings you want to view/modify
if None, all available subgroups from qt.QSettings will be setup in tabs
parent (qt.QWidget, optional):
parent of the widget
.. code-block:: python
:caption: Display settings for MORE THAN ONE module/group
from SlicerDevelopmentToolboxUtils.widgets import SettingsMessageBox
s = SettingsMessageBox(moduleNames=['Developer', 'DICOM'])
s.show()
.. code-block:: python
:caption: Display settings for ONE module/group
from SlicerDevelopmentToolboxUtils.widgets import SettingsMessageBox
s = SettingsMessageBox(moduleNames='DICOM')
s.show()
.. code-block:: python
:caption: Display settings for ALL available modules/groups
from SlicerDevelopmentToolboxUtils.widgets import SettingsMessageBox
s = SettingsMessageBox() # displays all available settings that are in groups
s.show()
See Also: :paramref:`SlicerDevelopmentToolboxUtils.buttons.ModuleSettingsButton`
"""
def __init__(self, moduleNames=None, parent=None, **kwargs):
self.moduleNames = [moduleNames] if type(moduleNames) is str else moduleNames
qt.QMessageBox.__init__(self, parent, **kwargs)
self._setup()
self.adjustSize()
def cleanup(self):
"""Cleans up the 'old' settings groupbox"""
if getattr(self, "settingGroupBox", None):
self.settingsTabWidget.setParent(None)
del self.settingsTabWidget
def show(self):
""" Displays the settings QMessageBox... All necessary ui components will be build depending on the settings type.
"""
self._createUIFromSettings()
qt.QMessageBox.show(self)
def _setup(self):
self.setLayout(qt.QGridLayout())
self.okButton = self.createButton("OK")
self.cancelButton = self.createButton("Cancel")
self.addButton(self.okButton, qt.QMessageBox.AcceptRole)
self.addButton(self.cancelButton, qt.QMessageBox.NoRole)
self.layout().addWidget(self.createHLayout([self.okButton, self.cancelButton]), 1, 1, 1, 2)
self.okButton.clicked.connect(self._onOkButtonClicked)
def _createUIFromSettings(self):
self.cleanup()
self._elements = []
self.settings = qt.QSettings()
self.settingsTabWidget = qt.QTabWidget()
moduleNames = self.moduleNames if self.moduleNames and len(self.moduleNames) else self._getSettingGroups()
for moduleName in moduleNames:
self._addModuleTab(moduleName)
self.layout().addWidget(self.settingsTabWidget, 0, 1, 1, 2)
def _addModuleTab(self, moduleName):
tabWidget = qt.QFrame()
tabWidget.setLayout(qt.QFormLayout())
self.settingsTabWidget.addTab(tabWidget, moduleName)
self._addSettingsGroup(moduleName, tabWidget)
def _addSettingsGroup(self, name, parent):
widget = qt.QFrame() if isinstance(parent, qt.QFrame) else qt.QGroupBox(name)
widget.setLayout(qt.QFormLayout())
self.settings.beginGroup(name)
for setting in self._getSettingAttributes():
self._addSettingsAttribute(widget, setting)
for groupName in self._getSettingGroups():
self._addSettingsGroup(groupName, widget.layout())
self.settings.endGroup()
parentLayout = parent.layout()
if isinstance(parentLayout, qt.QHBoxLayout):
parentLayout.addWidget(widget)
else:
parentLayout.addRow(widget)
def _getSettingAttributes(self):
separator = "/"
return filter(lambda x: separator not in x, self.settings.allKeys())
def _getSettingGroups(self):
separator = "/"
groups = set()
for subgroup in filter(lambda x: separator in x, self.settings.allKeys()):
groups.add(subgroup.split(separator)[0])
return groups
def _addSettingsAttribute(self, groupBox, setting):
value = self.settings.value(setting)
group = self.settings.group() + "/" if self.settings.group() else ""
if isinstance(value, tuple) or isinstance(value, list):
element = qt.QListWidget()
element.setProperty("type", type(value))
map(element.addItem, value)
elif isinstance(value, qt.QSize) or isinstance(value, qt.QPoint):
element = self._createDimensionalElement(value)
elif isinstance(value, qt.QByteArray):
logging.debug("Skipping %s which is a QByteArray" % group+setting)
return
else:
value = str(value)
if value.lower() in ["true", "false"]:
element = self._createCheckBox(value)
elif value.isdigit():
element = self._createSpinBox(value)
elif os.path.exists(value):
element = self._createPathLineEdit(value)
else:
element = self._createLineEdit(value)
if element:
element.setProperty("modified", False)
element.setProperty("attributeName", group+setting)
groupBox.layout().addRow(setting, element)
self._elements.append(element)
def _createDimensionalElement(self, value):
if isinstance(value, qt.QSize):
dimElement = SizeEdit(value.width(), value.height())
else:
dimElement = PointEdit(value.x(), value.y())
dimElement.setProperty("type", type(value))
dimElement.addEventObserver(dimElement.ModifiedEvent, lambda caller, event, e=dimElement: self._onAttributeModified(e))
return dimElement
def _createLineEdit(self, value):
lineEdit = self.createLineEdit(value, toolTip=value)
lineEdit.minimumWidth = self._getMinimumTextWidth(lineEdit.text) + 10
lineEdit.textChanged.connect(lambda text, e=lineEdit: self._onAttributeModified(e))
return lineEdit
def _createPathLineEdit(self, value):
pathLineEdit = ctk.ctkPathLineEdit()
if os.path.isdir(value):
pathLineEdit.filters = ctk.ctkPathLineEdit.Dirs
else:
pathLineEdit.filters = ctk.ctkPathLineEdit.Files
pathLineEdit.currentPath = value
pathLineEdit.toolTip =value
pathLineEdit.currentPathChanged.connect(lambda path, e=pathLineEdit: self._onAttributeModified(e))
return pathLineEdit
def _createSpinBox(self, value):
spinbox = qt.QSpinBox()
spinbox.setMaximum(999999)
spinbox.value = int(value)
spinbox.valueChanged.connect(lambda newVal, e=spinbox: self._onAttributeModified(e))
return spinbox
def _createCheckBox(self, value):
checkbox = qt.QCheckBox()
checkbox.checked = value.lower() == "true"
checkbox.toggled.connect(lambda enabled, e=checkbox: self._onAttributeModified(e))
return checkbox
def _onAttributeModified(self, element):
element.setProperty("modified", True)
def _getMinimumTextWidth(self, text):
font = qt.QFont("", 0)
metrics = qt.QFontMetrics(font)
return metrics.width(text)
def _onOkButtonClicked(self):
self.settings = qt.QSettings()
for element in self._elements:
if not element.property("modified"):
continue
if isinstance(element, qt.QCheckBox):
value = element.checked
elif isinstance(element, qt.QSpinBox):
value = str(element.value)
elif isinstance(element, ctk.ctkPathLineEdit):
value = element.currentPath
elif isinstance(element, qt.QListWidget):
if element.property("type") is tuple:
value = (element.item(i).text() for i in range(element.count))
else:
value = [element.item(i).text() for i in range(element.count)]
elif isinstance(element, SizeEdit):
value = qt.QSize(element.width, element.height)
elif isinstance(element, PointEdit):
value = qt.QPoint(element.x, element.y)
else:
value = element.text
attributeName = element.property("attributeName")
if not self.settings.contains(attributeName):
raise ValueError("QSetting attribute {} does not exist".format(attributeName))
if self.settings.value(attributeName) != value:
logging.debug("Setting value %s for attribute %s" %(value, attributeName))
self.settings.setValue(attributeName, value)
self.close()
class DimensionEditBase(qt.QWidget, ModuleWidgetMixin):
""" Base class widget for two dimensional inputs."""
ModifiedEvent = vtk.vtkCommand.UserEvent + 2324
""" Will be invoked whenever first or second dimension changes. """
def __init__(self, first, second, parent=None):
super(DimensionEditBase, self).__init__(parent)
self._setup(first, second)
self._setupConnections()
def _setup(self, first, second):
self.setLayout(qt.QHBoxLayout())
self.firstDimension = qt.QSpinBox()
self.firstDimension.maximum = 9999
self.firstDimension.setValue(first)
self.secondDimension = qt.QSpinBox()
self.secondDimension.maximum = 9999
self.secondDimension.setValue(second)
self.layout().addWidget(self.firstDimension)
self.layout().addWidget(self.secondDimension)
def _setupConnections(self):
self.firstDimension.valueChanged.connect(self._onValueChanged)
self.secondDimension.valueChanged.connect(self._onValueChanged)
def _onValueChanged(self, value):
self.invokeEvent(self.ModifiedEvent)
class SizeEdit(DimensionEditBase):
""" Widget representing a spinbox for width and another for height."""
@property
def width(self):
"""horizontal extent"""
return self.firstDimension.value
@width.setter
def width(self, width):
self.firstDimension.value = width
@property
def height(self):
"""vertical extent"""
return self.secondDimension.value
@height.setter
def height(self, height):
self.secondDimension.value = height
def __init__(self, width, height, parent=None):
super(SizeEdit, self).__init__(width, height, parent)
class PointEdit(DimensionEditBase):
""" Widget for displaying two dimensional position. One spinbox for x and another for y."""
@property
def x(self):
"""x position"""
return self.firstDimension.value
@x.setter
def x(self, x):
self.firstDimension.value = x
@property
def y(self):
"""y position"""
return self.secondDimension.value
@y.setter
def y(self, y):
self.secondDimension.value = y
def __init__(self, x, y, parent=None):
super(PointEdit, self).__init__(x, y, parent)
class ExtendedQMessageBox(qt.QMessageBox):
""" QMessageBox which is extended by an additional checkbox for remembering selection without notifying again."""
@property
def checkbox(self):
return self._checkbox if ModuleWidgetMixin.isQtVersionOlder() else self.checkBox()
@property
def text(self):
if ModuleWidgetMixin.isQtVersionOlder():
return self.textLabel.text
else:
return super(ExtendedQMessageBox, self).text
@text.setter
def text(self, text):
self.setText(text)
def __init__(self, parent= None):
super(ExtendedQMessageBox, self).__init__(parent)
self.setup()
def setup(self):
self._checkbox = qt.QCheckBox("Remember the selection and do not notify again")
if ModuleWidgetMixin.isQtVersionOlder():
self.textLabel = qt.QLabel()
self.layout().addWidget(self.textLabel, 0, 1)
self.layout().addWidget(self.checkbox, 1, 1)
else:
self.setCheckBox(self._checkbox)
self.checkbox.stateChanged.connect(self.onCheckboxStateChanged)
def onCheckboxStateChanged(self, state):
if state == 1:
self.showMsgBoxAgain = False
else:
self.showMsgBoxAgain = True
def setText(self, text):
if ModuleWidgetMixin.isQtVersionOlder():
self.textLabel.setText(text)
else:
qt.QMessageBox.setText(self, text)
def exec_(self, *args, **kwargs):
return qt.QMessageBox.exec_(self, *args, **kwargs), self.checkbox.isChecked()
class IncomingDataWindow(qt.QWidget, ModuleWidgetMixin):
""" Reception/import window for DICOM data into a specified directory sent via storescu or from a selected directory.
Besides running a DICOM receiver via storescp in the background, the operator also can choose to import recursively
from a directory. Once reception has finished, the window will automatically be hidden.
Note: The used port for incoming DICOM data is '11112'
Args:
incomingDataDirectory (str): directory where the received DICOM files will be stored
incomingPort (str, optional): port on which DICOM images are expected to be received
title (str, optional): window title
skipText (str, optional): text to be displayed for the skip button
cancelText (str, optional): text to be displayed for the cancel button
.. doctest::
def onReceptionFinished(caller, event):
print "Reception finished"
from SlicerDevelopmentToolboxUtils.widgets import IncomingDataWindow
window = IncomingDataWindow(slicer.app.temporaryPath)
window.addEventObserver(window.FinishedEvent, onReceptionFinished)
window.show()
# receive data on port 11112 and wait for slot to be called
See Also: :paramref:`SlicerDevelopmentToolboxUtils.helpers.SmartDICOMReceiver`
"""
SkippedEvent = SlicerDevelopmentToolboxEvents.SkippedEvent
"""Invoked when skip button was used"""
CanceledEvent = SlicerDevelopmentToolboxEvents.CanceledEvent
"""Invoked when cancel button was used"""
FinishedEvent = SlicerDevelopmentToolboxEvents.FinishedEvent
"""Invoked when reception has finished"""
def __init__(self, incomingDataDirectory, incomingPort=None, title="Receiving image data", skipText="Skip",
cancelText="Cancel", *args):
super(IncomingDataWindow, self).__init__(*args)
self.setWindowTitle(title)
self.setWindowFlags(qt.Qt.CustomizeWindowHint | qt.Qt.WindowTitleHint | qt.Qt.WindowStaysOnTopHint)
self.skipButtonText = skipText
self.cancelButtonText = cancelText
self.incomingPort = incomingPort
self._setup()
self._setupConnections()
self._setupDICOMReceiver(incomingDataDirectory)
self.dicomSender = None
def __del__(self):
super(IncomingDataWindow, self).__del__()
if self.dicomReceiver:
self.dicomReceiver.removeEventObservers()
@vtk.calldata_type(vtk.VTK_STRING)
def _onStatusChanged(self, caller, event, callData):
self.textLabel.text = callData
@vtk.calldata_type(vtk.VTK_INT)
def _onReceivingData(self, caller, event, callData):
self.skipButton.enabled = False
self.directoryImportButton.enabled = False
def show(self, disableWidget=None):
""" Opens the window and starts the DICOM reception process
Args:
disableWidget (qt.QWidget, optional): widget that needs to get disabled once IncomingDataWindow opens
"""
self.disabledWidget = disableWidget
if disableWidget:
disableWidget.enabled = False
qt.QWidget.show(self)
self.dicomReceiver.start()
def hide(self):
""" Closes the window, stops the DICOM reception process, and enables the widget that has been disabled (optional)
"""
if self.disabledWidget:
self.disabledWidget.enabled = True
self.disabledWidget = None
qt.QWidget.hide(self)
self.dicomReceiver.stop()
def _setup(self):
self.setLayout(qt.QGridLayout())
self.statusLabel = qt.QLabel("Status:")
self.textLabel = qt.QLabel()
self.layout().addWidget(self.statusLabel, 0, 0)
self.layout().addWidget(self.textLabel, 0, 1, 1, 2)
self.progress = qt.QProgressBar()
self.progress.maximum = 0
self.progress.setAlignment(qt.Qt.AlignCenter)
self.layout().addWidget(self.progress, 1, 0, 1, qt.QSizePolicy.Maximum)
self.buttonGroup = qt.QButtonGroup()
self.skipButton = self.createButton(self.skipButtonText)
self.cancelButton = self.createButton(self.cancelButtonText)
self.directoryImportButton = self.createDirectoryButton(text="Import from directory",
caption="Choose directory to import DICOM data from")
self.buttonGroup.addButton(self.skipButton)
self.buttonGroup.addButton(self.cancelButton)
self.layout().addWidget(self.skipButton, 2, 0)
self.layout().addWidget(self.cancelButton, 2, 1)
self.layout().addWidget(self.directoryImportButton, 2, 2)
buttonHeight = 30
for b in [self.skipButton, self.cancelButton, self.directoryImportButton]:
b.minimumHeight = buttonHeight
def _setupConnections(self):
self.buttonGroup.connect('buttonClicked(QAbstractButton*)', self._onButtonClicked)
self.directoryImportButton.directorySelected.connect(self._onImportDirectorySelected)
def _setupDICOMReceiver(self, incomingDataDirectory):
self.dicomReceiver = SmartDICOMReceiver(destinationDirectory=incomingDataDirectory,
incomingPort=self.incomingPort)
self.dicomReceiver.addEventObserver(self.dicomReceiver.StatusChangedEvent, self._onStatusChanged)
self.dicomReceiver.addEventObserver(self.dicomReceiver.IncomingDataReceiveFinishedEvent, self._onReceptionFinished)
self.dicomReceiver.addEventObserver(self.dicomReceiver.FileCountChangedEvent, self._onReceivingData)
def _onButtonClicked(self, button):
self.hide()
if button is self.skipButton:
self.invokeEvent(self.SkippedEvent)
else:
self.invokeEvent(self.CanceledEvent)
if self.dicomSender:
self.dicomSender.stop()
def _onReceptionFinished(self, caller, event):
self.hide()
self.invokeEvent(self.FinishedEvent)
def _onImportDirectorySelected(self, directory):
self.dicomSender = DICOMDirectorySender(directory, 'localhost', 11112)
class RatingMessageBox(qt.QMessageBox, ModuleWidgetMixin):
""" Provides a qt.QMessageBox with a number of stars (equivalent to maximum value) for rating e.g. a result.
.. image:: images/RatingMessageBox.png
:width: 40%
The number of stars is equivalent to the maximum rating value. Additionally there is a checkbox for preventing
the message box to be displayed again. The logic for not displaying it though needs to be implemented by the
user.
Args:
maximumValue (int): Maximum rating value
text (str, optional): Text to be displayed for the rating window.
.. code-block:: python
:caption: Display RatingMessageBox and invoke event once rating is done
import vtk
@vtk.calldata_type(vtk.VTK_INT)
def onRatingFinished(caller, event, ratingValue):
print "Rating finished with rating value %d" % ratingValue
def onRatingCanceled(caller, event):
print "Rating was canceled"
from SlicerDevelopmentToolboxUtils.widgets import RatingMessageBox
rating = RatingMessageBox(maximumValue=10)
rating.addEventObserver(rating.FinishedEvent, onRatingFinished)
rating.addEventObserver(rating.CanceledEvent, onRatingCanceled)
rating.show()
"""
CanceledEvent = SlicerDevelopmentToolboxEvents.CanceledEvent
""" Invoked when RatingMessageBox was closed without any rating. """
FinishedEvent = SlicerDevelopmentToolboxEvents.FinishedEvent
""" Invoked once a rating value has been selected. """
@property
def maximumValue(self):
""" Maximum rating value. """
return self._maximumValue
@maximumValue.setter
def maximumValue(self, value):
if value < 1:
raise ValueError("The maximum rating value cannot be less than 1.")
else:
self._maximumValue = value
def __init__(self, maximumValue, text="Please rate the result", *args):
qt.QMessageBox.__init__(self, *args)
self.maximumValue = maximumValue
self.text = text
self._setupIcons()
self._setup()
def __del__(self):
super(RatingMessageBox, self).__del__()
for button in self.buttons():
self._disconnectButton(button)
def isRatingEnabled(self):
""" Returns if rating is enabled. Depends on the checkbox displayed within the widget.
Returns:
bool: checkbox 'Don't display this window again' is unchecked. By default it is unchecked so the return value
would be True.
"""
return not self.disableWidgetCheckbox.checked
def show(self):
""" Opens the window
"""
self.ratingScore = None
self.ratingLabel.text = " "
qt.QMessageBox.show(self)
def reject(self):
""" Rejects rating and invokes CanceledEvent. """
qt.QMessageBox.reject(self)
def closeEvent(self, event):
""" Is called when close button is pressed. Invokes CanceledEvent. """
self.invokeEvent(self.CanceledEvent)
qt.QMessageBox.closeEvent(self, event)
self.reject()
def _setupIcons(self):
self.filledStarIcon = Icons.star_filled
self.unfilledStarIcon = Icons.star_unfilled
def _setup(self):
for rateValue in range(1, self.maximumValue+1):
button = self.createButton('', icon=self.unfilledStarIcon)
button.setProperty('value', rateValue)
button.setCursor(qt.Qt.PointingHandCursor)
button.installEventFilter(self)
self._connectButton(button)
self.addButton(button, qt.QMessageBox.AcceptRole)
self.ratingLabel = self.createLabel(" ")
width = self._getMinimumTextWidth(len(str(self.maximumValue))*" ")
self.ratingLabel.setFixedSize(width+12, 30)
row = self.createHLayout(list(self.buttons()) + [self.ratingLabel])
self.layout().addWidget(row, 2, 1)
self.disableWidgetCheckbox = qt.QCheckBox("Don't display this window again")
self.disableWidgetCheckbox.checked = False
self.layout().addWidget(self.disableWidgetCheckbox, 4, 1)
def _connectButton(self, button):
button.clicked.connect(lambda: self._onRatingButtonClicked(button.value))
def _disconnectButton(self, button):
button.clicked.disconnect(lambda: self._onRatingButtonClicked(button.value))
def eventFilter(self, obj, event):
if obj in self.buttons() and event.type() == qt.QEvent.HoverEnter:
self._onHoverEvent(obj)
elif obj in self.buttons() and event.type() == qt.QEvent.HoverLeave:
self._onLeaveEvent()
return qt.QWidget.eventFilter(self, obj, event)
def _onLeaveEvent(self):
for button in self.buttons():
button.icon = self.unfilledStarIcon
def _onHoverEvent(self, obj):
ratingValue = 0
for button in self.buttons():
button.icon = self.filledStarIcon
ratingValue += 1
if obj is button:
break
self.ratingLabel.setText(str(ratingValue))
def _onRatingButtonClicked(self, value):
self.ratingScore = value
self.invokeEvent(self.FinishedEvent, self.ratingScore)
class BasicInformationWatchBox(qt.QGroupBox):
""" BasicInformationWatchBox can be used for displaying basic information like patient name, birthday, but also other.
.. |bpw1| image:: images/BasicPatientWatchBox_one_colum.png
.. |bpw2| image:: images/BasicPatientWatchBox_two_colums.png
.. |bpw3| image:: images/BasicPatientWatchBox_three_colums.png
+-----------+---------------+-----------------+
| One column| Two columns | Three columns |
+===========+===============+=================+
| |bpw1| | |bpw2| | |bpw3| |
+-----------+---------------+-----------------+
Args:
attributes (list): list of WatchBoxAttributes
title (str, optional): text to be displayed in the upper left corner of the BasicInformationWatchBox
parent (qt.QWidget, optional): parent of the button
columns (int, optional): number of columns in which key/value pairs will be displayed
.. code-block:: python
:caption: Display some basic information about a patient
from SlicerDevelopmentToolboxUtils.helpers import WatchBoxAttribute
from SlicerDevelopmentToolboxUtils.widgets import BasicInformationWatchBox
from datetime import datetime
patientWatchBoxInformation = [WatchBoxAttribute('PatientName', 'Name: '),
WatchBoxAttribute('PatientID', 'PID: '),
WatchBoxAttribute('StudyDate', 'Study Date: ')]
patientWatchBox = BasicInformationWatchBox(patientWatchBoxInformation, title="Patient Information")
patientWatchBox.show()
patientWatchBox.setInformation('PatientName', 'Doe, John')
patientWatchBox.setInformation('PatientID', '12345')
patientWatchBox.setInformation('StudyDate', datetime.now().strftime("%Y_%m_%d"))
See Also:
:paramref:`SlicerDevelopmentToolboxUtils.helpers.WatchBoxAttribute`
:paramref:`SlicerDevelopmentToolboxUtils.widgets.FileBasedInformationWatchBox`
:paramref:`SlicerDevelopmentToolboxUtils.widgets.XMLBasedInformationWatchBox`
:paramref:`SlicerDevelopmentToolboxUtils.widgets.DICOMBasedInformationWatchBox`
"""
_DEFAULT_STYLE = 'background-color: rgb(230,230,230)'
_dateFormat = "%Y-%b-%d"
@staticmethod
def _formatPatientName(name):
if name != "":
splitted = name.split('^')
try:
name = splitted[1] + ", " + splitted[0]
except IndexError:
name = splitted[0]
return name
def __init__(self, attributes, title="", parent=None, columns=1):
if columns <= 0:
raise ValueError("Number of columns cannot be smaller than 1")
super(BasicInformationWatchBox, self).__init__(title, parent)
self.attributes = attributes
self.columns = columns
if not self._checkAttributeUniqueness():
raise ValueError("Attribute names are not unique.")
self._setup()
def reset(self):
""" Sets all values (not keys) to ''
"""
for attribute in self.attributes:
attribute.value = ""
def _checkAttributeUniqueness(self):
onlyNames = [attribute.name for attribute in self.attributes]
return len(self.attributes) == len(set(onlyNames))
def _setup(self):
self.setStyleSheet(self._DEFAULT_STYLE)
self.setLayout(qt.QGridLayout())
def addPairAndReturnNewColumn(title, value, row, column):
self.layout().addWidget(title, row, column*2, 1, 1, qt.Qt.AlignLeft)
self.layout().addWidget(value, row, column*2+1, 1, 1, qt.Qt.AlignLeft)
return column+1 if column<self.columns-1 else 0
column = 0
for index, attribute in enumerate(self.attributes):
column = addPairAndReturnNewColumn(attribute.titleLabel, attribute.valueLabel, index/self.columns, column)
while column != 0 and column <= self.columns-1:
column = addPairAndReturnNewColumn(qt.QLabel(""), qt.QLabel(""), index/self.columns, column)
def _formatDate(self, dateToFormat):
if dateToFormat and dateToFormat != "":
formatted = datetime.date(int(dateToFormat[0:4]), int(dateToFormat[4:6]), int(dateToFormat[6:8]))
return formatted.strftime(self._dateFormat)
return "No Date found"
def setPreferredDateFormat(self, dateFormat):
""" Setting the preferred format dates should be displayed
See Also: https://docs.python.org/2/library/datetime.html#datetime.datetime.strftime
"""
self._dateFormat = dateFormat
def setInformation(self, attributeName, value, toolTip=None):
attribute = self.getAttribute(attributeName)
attribute.value = value
attribute.valueLabel.toolTip = toolTip
def getInformation(self, attributeName):
""" Retrieve information by delivering the attribute name.
Returns:
value if WatchBoxAttribute was set to masked else the original value
"""
attribute = self.getAttribute(attributeName)
return attribute.value if not attribute.masked else attribute.originalValue
def getAttribute(self, name):
""" Retrieve attribute by attribute name.
Returns:
None if attribute name was not found else WatchBoxAttribute
"""
for attribute in self.attributes:
if attribute.name == name:
return attribute
return None
class FileBasedInformationWatchBox(BasicInformationWatchBox):
""" FileBasedInformationWatchBox is a base class for file based information that should be displayed in a watchbox
See Also:
:paramref:`SlicerDevelopmentToolboxUtils.helpers.WatchBoxAttribute`
:paramref:`SlicerDevelopmentToolboxUtils.widgets.BasicInformationWatchBox`
"""
DEFAULT_TAG_VALUE_SEPARATOR = ": "
DEFAULT_TAG_NAME_SEPARATOR = "_"
@property
def sourceFile(self):
""" Source file which information should be displayed in the watchbox. """
self._sourceFile = getattr(self, "_sourceFile", None)
return self._sourceFile
@sourceFile.setter
def sourceFile(self, filePath):
self._sourceFile = filePath
if not filePath:
self.reset()
self.updateInformation()
def __init__(self, attributes, title="", sourceFile=None, parent=None, columns=1):
super(FileBasedInformationWatchBox, self).__init__(attributes, title, parent, columns)
if sourceFile:
self.sourceFile = sourceFile
def _getTagNameFromTagNames(self, tagNames):
return self.DEFAULT_TAG_NAME_SEPARATOR.join(tagNames)
def _getTagValueFromTagValues(self, values):
return self.DEFAULT_TAG_VALUE_SEPARATOR.join(values)
def updateInformation(self):
""" Forcing information to be updated from files.
If no callback is implemented for the attribute, the information will be updated from WatchBoxAttribute.
"""
for attribute in self.attributes:
if attribute.callback:
value = attribute.callback()
else:
value = self.updateInformationFromWatchBoxAttribute(attribute)
self.setInformation(attribute.name, value, toolTip=value)
def updateInformationFromWatchBoxAttribute(self, attribute):
""" This method implements the strategy how watchbox information are retrieve from files.
Note: This method needs to be implemented by inheriting classes.
"""
raise NotImplementedError
class XMLBasedInformationWatchBox(FileBasedInformationWatchBox):
""" XMLBasedInformationWatchBox is based on xml file based information that should be displayed in a watchbox.
.. image:: images/XMLBasedInformationWatchBox.png
.. code-block:: python
:caption: Display information retrieved from a xml file
from SlicerDevelopmentToolboxUtils.helpers import WatchBoxAttribute
from SlicerDevelopmentToolboxUtils.widgets import XMLBasedInformationWatchBox
import os
watchBoxInformation = [WatchBoxAttribute('PatientName', 'Name:', 'PatientName'),
WatchBoxAttribute('StudyDate', 'Study Date:', 'StudyDate'),
WatchBoxAttribute('PatientID', 'PID:', 'PatientID'),
WatchBoxAttribute('PatientBirthDate', 'DOB:', 'PatientBirthDate')]
informationWatchBox = XMLBasedInformationWatchBox(watchBoxInformation, columns=2)
informationWatchBox.sourceFile = os.path.join(os.path.dirname(slicer.util.modulePath("SlicerDevelopmentToolbox")),
"doc", "data", "XMLBasedInformationWatchBoxTest.xml")
informationWatchBox.show()
See Also:
:paramref:`SlicerDevelopmentToolboxUtils.helpers.WatchBoxAttribute`
:paramref:`SlicerDevelopmentToolboxUtils.widgets.FileBasedInformationWatchBox`
:paramref:`SlicerDevelopmentToolboxUtils.widgets.BasicInformationWatchBox`
"""
DATE_TAGS_TO_FORMAT = ["StudyDate", "PatientBirthDate", "SeriesDate", "ContentDate", "AcquisitionDate"]
""" A list of date attributes names as defined for every WatchBoxAttribute that needs to be formatted
See Also:
:paramref:`SlicerDevelopmentToolboxUtils.helpers.WatchBoxAttribute`
"""
@FileBasedInformationWatchBox.sourceFile.setter
def sourceFile(self, filePath):
self._sourceFile = filePath
if filePath:
self.dom = xml.dom.minidom.parse(self._sourceFile)
else:
self.reset()
self.updateInformation()
def __init__(self, attributes, title="", sourceFile=None, parent=None, columns=1):
super(XMLBasedInformationWatchBox, self).__init__(attributes, title, sourceFile, parent, columns)
def reset(self):
super(XMLBasedInformationWatchBox, self).reset()
self.dom = None
def updateInformationFromWatchBoxAttribute(self, attribute):
if attribute.tags and self.dom:
values = []
for tag in attribute.tags:
currentValue = ModuleLogicMixin.findElement(self.dom, tag)
if tag in self.DATE_TAGS_TO_FORMAT:
currentValue = self._formatDate(currentValue)
elif tag == "PatientName":
currentValue = self._formatPatientName(currentValue)
values.append(currentValue)
return self._getTagValueFromTagValues(values)
return ""
class DICOMBasedInformationWatchBox(FileBasedInformationWatchBox):
""" DICOMBasedInformationWatchBox is based on information retrieved from DICOM that should be displayed in a watchbox.
.. image:: images/DICOMBasedInformationWatchBox.png
.. code-block:: python
:caption: Display information retrieved from a DICOM file
from SlicerDevelopmentToolboxUtils.helpers import WatchBoxAttribute
from SlicerDevelopmentToolboxUtils.widgets import DICOMBasedInformationWatchBox
from SlicerDevelopmentToolboxUtils.constants import DICOMTAGS
import os
WatchBoxAttribute.TRUNCATE_LENGTH = 20
watchBoxInformation = [WatchBoxAttribute('PatientName', 'Name: ', DICOMTAGS.PATIENT_NAME),
WatchBoxAttribute('PatientID', 'PID: ', DICOMTAGS.PATIENT_ID),
WatchBoxAttribute('DOB', 'DOB: ', DICOMTAGS.PATIENT_BIRTH_DATE)]
informationWatchBox = DICOMBasedInformationWatchBox(watchBoxInformation, title="Patient Information")
filename = "1.3.6.1.4.1.43046.3.330964839400343291362242315939623549555"
informationWatchBox.sourceFile = os.path.join(os.path.dirname(slicer.util.modulePath("SlicerDevelopmentToolbox")),
"doc", "data", filename)
informationWatchBox.show()
See Also:
:paramref:`SlicerDevelopmentToolboxUtils.helpers.WatchBoxAttribute`
:paramref:`SlicerDevelopmentToolboxUtils.widgets.FileBasedInformationWatchBox`
:paramref:`SlicerDevelopmentToolboxUtils.widgets.BasicInformationWatchBox`
"""
DATE_TAGS_TO_FORMAT = [DICOMTAGS.STUDY_DATE, DICOMTAGS.PATIENT_BIRTH_DATE]
def __init__(self, attributes, title="", sourceFile=None, parent=None, columns=1):
super(DICOMBasedInformationWatchBox, self).__init__(attributes, title, sourceFile, parent, columns)
def updateInformationFromWatchBoxAttribute(self, attribute):
if attribute.tags and self.sourceFile:
values = []
for tag in attribute.tags:
currentValue = ModuleLogicMixin.getDICOMValue(self.sourceFile, tag, "")
if tag in self.DATE_TAGS_TO_FORMAT:
currentValue = self._formatDate(currentValue)
elif tag == DICOMTAGS.PATIENT_NAME:
currentValue = self._formatPatientName(currentValue)
values.append(currentValue)
return self._getTagValueFromTagValues(values)
return ""
class DICOMConnectionTestWidget(qt.QDialog, ModuleWidgetMixin):
""" Dialog for testing network connectivity specifically for DICOM reception.
.. |pic1| image:: images/DICOMConnectionTestWidget_initial_status.png
.. |pic2| image:: images/DICOMConnectionTestWidget_waiting_status.png
.. |pic3| image:: images/DICOMConnectionTestWidget_success_status.png
+--------+-----------+-----------+
| Initial| Waiting | Success |
+========+===========+===========+
| |pic1| | |pic2| | |pic3| |
+--------+-----------+-----------+
Can be used to test the reception of DICOM data on a specified port. Once the start buttons is clickeda temporary
directory will be created under slicer.app.temporaryPath. Closing the dialog will stop the DICOM receiver (in case
it's running) and the temporarily created directory will be deleted.
Args:
incomingPort (str, optional): port on which DICOM data is expected to be received. Default: 11112
parent (qt.QWidget, optional): parent of the widget
.. doctest::
from SlicerDevelopmentToolboxUtils.widgets import DICOMConnectionTestWidget
dicomTestWidget = DICOMConnectionTestWidget()
dicomTestWidget.show()
"""
__Initial_Style = 'background-color: indianred; color: black;'
__Waiting_Style = 'background-color: gold; color: black;'
__Success_Style = 'background-color: green; color: white;'
__Initial_Status_Text = "Not Running."
__Success_Status_Text = "DICOM connection successfully tested!"
SuccessEvent = SlicerDevelopmentToolboxEvents.SuccessEvent
def __init__(self, incomingPort="11112", parent=None):
qt.QDialog.__init__(self, parent)
self.__dicomReceiver = None
self.__incomingPort = incomingPort
self.modal = True
self.success = False
self.setup()
def setup(self):
""" Setup user interface including signal connections"""
self.setLayout(qt.QGridLayout())
self.incomingPortSpinBox = qt.QSpinBox()
self.incomingPortSpinBox.setMaximum(65535)
if self.__incomingPort:
self.incomingPortSpinBox.setValue(int(self.__incomingPort))
self.startButton = self.createButton("Start")
self.stopButton = self.createButton("Stop", enabled=False)
self.statusEdit = self.createLineEdit(self.__Initial_Status_Text, enabled=False)
self.statusEdit.setStyleSheet(self.__Initial_Style)
self.layout().addWidget(qt.QLabel("Port:"), 0, 0)
self.layout().addWidget(self.incomingPortSpinBox, 0, 1)
self.layout().addWidget(qt.QLabel("Status:"), 1, 0)
self.layout().addWidget(self.statusEdit, 1, 1)
self.layout().addWidget(self.startButton, 2, 0)
self.layout().addWidget(self.stopButton, 2, 1)
self._setupConnections()
def show(self):
"""Displays the dialog"""
self.statusEdit.setText(self.__Initial_Status_Text)
qt.QDialog.show(self)
def hide(self):
"""Hides the dialog, stops the DICOM receiver in case it is running and deletes the temporarily created directory"""
self._cleanup()
qt.QDialog.hide()
def reject(self):
"""Rejects the dialog and cleans up DICOM receiver and temporarily created directory"""
self._cleanup()
qt.QDialog.reject(self)
def _setupConnections(self):
self.startButton.clicked.connect(self._onStartButtonClicked)
self.stopButton.clicked.connect(self._onStopButtonClicked)
self.statusEdit.textChanged.connect(self._onStatusEditTextChanged)
self.incomingPortSpinBox.valueChanged.connect(lambda value: self.statusEdit.setText(self.__Initial_Status_Text))
def _onStartButtonClicked(self):
self.startButton.enabled = False
self.incomingPortSpinBox.enabled = False
self.stopButton.enabled = True
self._start()
def _start(self):
from datetime import datetime
directory = os.path.join(slicer.app.temporaryPath, datetime.now().strftime("%Y_%m_%d_%H_%M_%S"))
ModuleLogicMixin.createDirectory(directory)
self.__dicomReceiver = SmartDICOMReceiver(directory, self.incomingPortSpinBox.value)
self.__dicomReceiver.addEventObserver(SmartDICOMReceiver.StatusChangedEvent, self._onDICOMReceiverStatusChanged)
self.__dicomReceiver.addEventObserver(SmartDICOMReceiver.FileCountChangedEvent, self._onFilesReceived)
self.__dicomReceiver.start()
self.statusEdit.setStyleSheet(self.__Waiting_Style)
@vtk.calldata_type(vtk.VTK_STRING)
def _onDICOMReceiverStatusChanged(self, caller, event, callData):
self.statusEdit.setText(callData)
self.statusEdit.setStyleSheet(self.__Initial_Style)
@vtk.calldata_type(vtk.VTK_INT)
def _onFilesReceived(self, caller, event, count):
self._onStopButtonClicked()
self.statusEdit.setText(self.__Success_Status_Text)
self.statusEdit.setStyleSheet(self.__Success_Style)
self.invokeEvent(self.SuccessEvent)
def _onStopButtonClicked(self):
self.startButton.enabled = True
self.incomingPortSpinBox.enabled = True
self.stopButton.enabled = False
self.__dicomReceiver.stop()
self.__dicomReceiver.removeEventObservers()
self.statusEdit.setText(self.__Initial_Status_Text)
self.statusEdit.setStyleSheet(self.__Initial_Style)
def _onStatusEditTextChanged(self, text):
width = self._getMinimumTextWidth(text)
if width > self.statusEdit.width:
self.statusEdit.setFixedSize(width+12, self.statusEdit.height) # border width: 2+2 and padding: 8 = 2+2+8=12
def _cleanup(self):
if self.__dicomReceiver:
if self.__dicomReceiver.isRunning():
self._onStopButtonClicked()
try:
import shutil
shutil.rmtree(self.__dicomReceiver.destinationDirectory)
except OSError:
pass
finally:
self.__dicomReceiver = None
class ImportIntoSegmentationWidgetBase(qt.QWidget, ModuleWidgetMixin):
StartedEvent = SlicerDevelopmentToolboxEvents.StartedEvent
FailedEvent = SlicerDevelopmentToolboxEvents.FailedEvent
SuccessEvent = SlicerDevelopmentToolboxEvents.SuccessEvent
_LayoutClass = None
@property
def busy(self):
return self._busy
@property
def segmentationNodeSelectorVisible(self):
return self.segmentationNodeSelector.visible
@segmentationNodeSelectorVisible.setter
def segmentationNodeSelectorVisible(self, visible):
self.segmentationNodeSelector.visible = visible
self.segmentationLabel.visible = visible
@property
def segmentationNodeSelectorEnabled(self):
return self.currentSegmentationNodeSelector.enabled
@segmentationNodeSelectorEnabled.setter
def segmentationNodeSelectorEnabled(self, enabled):
self.currentSegmentationNodeSelector.enabled = enabled
def __init__(self, parent=None):
qt.QWidget.__init__(self, parent)
self._busy = False
self.setup()
self._setupConnections()
def setup(self):
self.segmentationNodeSelector = self._createSegmentationNodeSelector()
if not self._LayoutClass:
raise NotImplementedError
self.setLayout(self._LayoutClass())
def _setupConnections(self):
raise NotImplementedError
def invokeEvent(self, event, callData=None):
self._busy = event == self.StartedEvent
ModuleWidgetMixin.invokeEvent(self, event, callData)
def setSegmentationNode(self, segmentationNode):
if segmentationNode and not isinstance(segmentationNode, slicer.vtkMRMLSegmentationNode):
raise ValueError("The delivered node needs to be a vtkMRMLSegmentationNode")
self.segmentationNodeSelector.setCurrentNode(segmentationNode)
def _createSegmentationNodeSelector(self):
return self.createComboBox(nodeTypes=["vtkMRMLSegmentationNode", ""],showChildNodeTypes=False,
selectNodeUponCreation=False, toolTip="Select Segmentation")
class CopySegmentBetweenSegmentationsWidget(ImportIntoSegmentationWidgetBase):
""" This widget can be used to move/copy segments between two segmentations or import labelmaps into a segmentation
.. code-block:: python
from SlicerDevelopmentToolboxUtils.widgets import CopySegmentBetweenSegmentationsWidget
w = CopySegmentBetweenSegmentationsWidget()
w.show()
"""
_LayoutClass = qt.QGridLayout
@property
def currentSegmentationNodeSelector(self):
return self.segmentationNodeSelector
def __init__(self, parent=None):
super(CopySegmentBetweenSegmentationsWidget, self).__init__(parent)
def setup(self):
super(CopySegmentBetweenSegmentationsWidget, self).setup()
self.relatedUIElements = {}
self.currentSegmentsTableView = self._createSegmentsTableView()
self.relatedUIElements[self.currentSegmentationNodeSelector] = self.currentSegmentsTableView
iconSize = qt.QSize(36,36)
self.moveCurrentToOtherButton = self.createButton("", toolTip="Move segment", icon=Icons.move_to_right,
iconSize=iconSize, enabled=False)
self.copyCurrentToOtherButton = self.createButton("", toolTip="Copy segment", icon=Icons.copy_to_right,
iconSize=iconSize, enabled=False)
self.copyOtherToCurrentButton = self.createButton("", toolTip="Copy segment", icon=Icons.copy_to_left,
iconSize=iconSize, enabled=False)
self.moveOtherToCurrentButton = self.createButton("", toolTip="Move segment", icon=Icons.move_to_left,
iconSize=iconSize, enabled=False)
self.otherSegmentationNodeSelector = self._createSegmentationNodeSelector()
self.otherSegmentsTableView = self._createSegmentsTableView()
self.relatedUIElements[self.otherSegmentationNodeSelector] = self.otherSegmentsTableView
self.infoLabel = self.createLabel("", enabled=False)
self.layout().addWidget(self.currentSegmentationNodeSelector, 0, 0)
self.layout().addWidget(self.otherSegmentationNodeSelector, 0, 2)
self.layout().addWidget(self.currentSegmentsTableView, 1, 0, 4, 1)
self.layout().addWidget(self.otherSegmentsTableView, 1, 2, 4, 1)
self.layout().addWidget(self.copyCurrentToOtherButton, 1, 1)
self.layout().addWidget(self.moveCurrentToOtherButton, 2, 1)
self.layout().addWidget(self.copyOtherToCurrentButton, 3, 1)
self.layout().addWidget(self.moveOtherToCurrentButton, 4, 1)
self.layout().addWidget(self.infoLabel, 5, 0, 1, 3)
def createButton(self, title, **kwargs):
button = qt.QToolButton()
button.text = title
button.setCursor(qt.Qt.PointingHandCursor)
button = self.extendQtGuiElementProperties(button, **kwargs)
button.setSizePolicy(qt.QSizePolicy.Minimum, qt.QSizePolicy.Expanding)
return button
def _createSegmentsTableView(self):
tableView = slicer.qMRMLSegmentsTableView()
tableView.setHeaderVisible(False)
tableView.setVisibilityColumnVisible(False)
tableView.setOpacityColumnVisible(False)
tableView.setColorColumnVisible(False)
tableView.setSizePolicy(qt.QSizePolicy.Expanding, qt.QSizePolicy.Expanding)
tableView.SegmentsTableMessageLabel.hide()
return tableView
def _setupConnections(self):
self.currentSegmentationNodeSelector.connect('currentNodeChanged(vtkMRMLNode*)',
lambda node: self._onSegmentationSelected(self.currentSegmentationNodeSelector,
node,
self.otherSegmentationNodeSelector))
self.otherSegmentationNodeSelector.connect('currentNodeChanged(vtkMRMLNode*)',
lambda node: self._onSegmentationSelected(self.otherSegmentationNodeSelector,
node,
self.currentSegmentationNodeSelector))
self.currentSegmentsTableView.selectionChanged.connect(lambda selected, deselected: self.updateView())
self.otherSegmentsTableView.selectionChanged.connect(lambda selected, deselected: self.updateView())
self.copyCurrentToOtherButton.clicked.connect(lambda: self._copySegmentsBetweenSegmentations(True, False))
self.copyOtherToCurrentButton.clicked.connect(lambda: self._copySegmentsBetweenSegmentations(False, False))
self.moveCurrentToOtherButton.clicked.connect(lambda: self._copySegmentsBetweenSegmentations(True, True))
self.moveOtherToCurrentButton.clicked.connect(lambda: self._copySegmentsBetweenSegmentations(False, True))
def _onSegmentationSelected(self, selector, node, contrary):
tableView = self.relatedUIElements[selector]
message = ""
if node and node is contrary.currentNode():
node = None
message = "Warning: Cannot have the same segmentation selected on both sides"
selector.setCurrentNode(node)
tableView.setSegmentationNode(node)
tableView.SegmentsTableMessageLabel.hide()
self.infoLabel.setText(message)
self.updateView()
def setCurrentSegmentationNode(self, segmentationNode):
super(CopySegmentBetweenSegmentationsWidget, self).setSegmentationNode(segmentationNode)
def updateView(self):
valid = self.currentSegmentationNodeSelector.currentNode() and self.otherSegmentationNodeSelector.currentNode()
self.copyCurrentToOtherButton.enabled = valid and len(self.currentSegmentsTableView.selectedSegmentIDs())
self.copyOtherToCurrentButton.enabled = valid and len(self.otherSegmentsTableView.selectedSegmentIDs())
self.moveCurrentToOtherButton.enabled = valid and len(self.currentSegmentsTableView.selectedSegmentIDs())
self.moveOtherToCurrentButton.enabled = valid and len(self.otherSegmentsTableView.selectedSegmentIDs())
self.currentSegmentsTableView.SegmentsTableMessageLabel.hide()
self.otherSegmentsTableView.SegmentsTableMessageLabel.hide()
def _copySegmentsBetweenSegmentations(self, copyFromCurrentSegmentation, removeFromSource):
self.invokeEvent(self.StartedEvent)
currentSegmentationNode = self.currentSegmentationNodeSelector.currentNode()
otherSegmentationNode = self.otherSegmentationNodeSelector.currentNode()
if not (currentSegmentationNode and otherSegmentationNode):
logging.info("Current and other segmentation node needs to be selected")
self.invokeEvent(self.FailedEvent)
return
if copyFromCurrentSegmentation:
sourceSegmentation = currentSegmentationNode.GetSegmentation()
targetSegmentation = otherSegmentationNode.GetSegmentation()
otherSegmentationNode.CreateDefaultDisplayNodes()
selectedSegmentIds = self.currentSegmentsTableView.selectedSegmentIDs()
else:
sourceSegmentation = otherSegmentationNode.GetSegmentation()
targetSegmentation = currentSegmentationNode.GetSegmentation()
currentSegmentationNode.CreateDefaultDisplayNodes()
selectedSegmentIds = self.otherSegmentsTableView.selectedSegmentIDs()
if not len(selectedSegmentIds):
logging.warn("No segments are selected")
self.invokeEvent(self.FailedEvent)
return
for segmentID in selectedSegmentIds:
if not targetSegmentation.CopySegmentFromSegmentation(sourceSegmentation, segmentID, removeFromSource):
self.invokeEvent(self.FailedEvent)
raise RuntimeError("Segment %s could not be copied from segmentation %s tp %s " %(segmentID,
sourceSegmentation.GetName(),
targetSegmentation.GetName()))
return self.invokeEvent(self.SuccessEvent)
class ImportLabelMapIntoSegmentationWidget(ImportIntoSegmentationWidgetBase):
""" This widget provides functionality for importing from a labelmap into a segmentation
.. code-block:: python
from SlicerDevelopmentToolboxUtils.widgets import ImportLabelMapIntoSegmentationWidget
w = ImportLabelMapIntoSegmentationWidget()
w.segmentationNodeSelectorVisible = False
w.show()
"""
CanceledEvent = SlicerDevelopmentToolboxEvents.CanceledEvent
_LayoutClass = qt.QFormLayout
def __init__(self, parent=None):
self.logic = ImportLabelMapIntoSegmentationLogic()
super(ImportLabelMapIntoSegmentationWidget, self).__init__(parent)
self._connectLogicEvents()
def setup(self):
super(ImportLabelMapIntoSegmentationWidget, self).setup()
self.segmentationLabel = qt.QLabel("Destination segmentation")
self.labelMapSelector = self.createComboBox(nodeTypes=["vtkMRMLLabelMapVolumeNode", ""], showChildNodeTypes=False,
addEnabled=False, removeEnabled=False, noneEnabled=True,
selectNodeUponCreation=False, toolTip="Select labelmap to import from")
self.importButton = self.createButton("Import", enabled=False)
self.layout().addRow(self.segmentationLabel, self.segmentationNodeSelector)
self.layout().addRow(qt.QLabel("Input labelmap:"), self.labelMapSelector)
self.layout().addRow(self.importButton)
def _setupConnections(self):
self.segmentationNodeSelector.connect('currentNodeChanged(vtkMRMLNode*)',
lambda node: self._updateButtonAvailability())
self.labelMapSelector.connect('currentNodeChanged(vtkMRMLNode*)', lambda node: self._updateButtonAvailability())
self.importButton.clicked.connect(self.logic.run)
def _connectLogicEvents(self):
self.logic.addEventObserver(self.logic.StartedEvent, lambda c, e: self.invokeEvent(self.StartedEvent))
self.logic.addEventObserver(self.logic.FailedEvent, lambda c, e: self.invokeEvent(self.FailedEvent))
self.logic.addEventObserver(self.logic.SuccessEvent, lambda c, e: self.invokeEvent(self.SuccessEvent))
self.logic.addEventObserver(self.logic.ResampleWarningEvent, self.onResampleWarning)
def _updateButtonAvailability(self):
self.logic.segmentationNode = self.segmentationNodeSelector.currentNode()
self.logic.labelmap = self.labelMapSelector.currentNode()
self.importButton.setEnabled(self.logic.segmentationNode and self.logic.labelmap)
@vtk.calldata_type(vtk.VTK_STRING)
def onResampleWarning(self, caller, event, callData):
if slicer.util.confirmYesNoDisplay("Geometry of master and label do not match. Do you want to resample the "
"label?", detailedText=callData):
self.logic.run(resampleIfNecessary=True)
else:
self.invokeEvent(self.CanceledEvent)
class ImportLabelMapIntoSegmentationLogic(ParameterNodeObservationMixin):
StartedEvent = SlicerDevelopmentToolboxEvents.StartedEvent
SuccessEvent = SlicerDevelopmentToolboxEvents.SuccessEvent
FailedEvent = SlicerDevelopmentToolboxEvents.FailedEvent
ResampleWarningEvent = vtk.vtkCommand.UserEvent + 301
@property
def labelmap(self):
return self._labelmap
@labelmap.setter
def labelmap(self, node):
self._labelmap = node
@property
def segmentationNode(self):
return self._segmentationNode
@segmentationNode.setter
def segmentationNode(self, node):
self._segmentationNode = node
def __init__(self, segmentationNode=None, labelmap=None):
self._labelmap = labelmap
self._segmentationNode = segmentationNode
self.volumesLogic = slicer.modules.volumes.logic()
def run(self, resampleIfNecessary=False):
self.invokeEvent(self.StartedEvent)
logging.debug("Starting import labelmap %s into segmentation %s" % (self.labelmap.GetName(),
self.segmentationNode.GetName()))
masterVolume = ModuleLogicMixin.getReferencedVolumeFromSegmentationNode(self.segmentationNode)
labelmap = self.labelmap
if not masterVolume:
raise ValueError("No referenced master volume found for %s" % self.segmentationNode.GetName())
warnings = self.volumesLogic.CheckForLabelVolumeValidity(masterVolume, self.labelmap)
if warnings != "":
if not resampleIfNecessary:
self.invokeEvent(self.ResampleWarningEvent, warnings)
return
else:
labelmap = self._resampleLabel(masterVolume)
self.segmentationNode.CreateDefaultDisplayNodes()
segmentationsLogic = slicer.modules.segmentations.logic()
slicer.app.setOverrideCursor(qt.QCursor(qt.Qt.BusyCursor))
success = segmentationsLogic.ImportLabelmapToSegmentationNode(labelmap, self.segmentationNode)
slicer.app.restoreOverrideCursor()
if not success:
message = "Failed to copy labels from labelmap volume node %s!" % labelmap.GetName()
logging.error(message)
slicer.util.warningDisplay("Failed to import from labelmap volume")
self.invokeEvent(self.FailedEvent)
return
self.invokeEvent(self.SuccessEvent)
def _resampleLabel(self, masterVolume):
outputLabel = slicer.mrmlScene.AddNewNodeByClass("vtkMRMLLabelMapVolumeNode")
outputLabel.SetName(self.labelmap.GetName() + "_resampled")
ModuleLogicMixin.runBRAINSResample(inputVolume=self.labelmap, referenceVolume=masterVolume,
outputVolume=outputLabel)
return outputLabel
class SliceWidgetDialogBase(qt.QDialog, ModuleWidgetMixin):
""" This class represents the base of a slice widget based dialog
"""
def __init__(self, volumeNode, text="", labelNode=None, parent=None, **kwargs):
qt.QDialog.__init__(self, parent if parent else slicer.util.mainWindow())
self.volumeNode = volumeNode
self.labelNode = labelNode
self.text = text
self.standardButtons = None
self.clickedButton = None
for key, value in kwargs.iteritems():
if hasattr(self, key):
setattr(self, key, value)
self.setup()
self.setupConnections()
def setup(self):
self.setupSliceWidget()
self.setLayout(qt.QGridLayout())
self.layout().addWidget(self.sliceWidget, 0, 0)
self.layout().addWidget(qt.QLabel(self.text), 1, 0)
self.buttonBox = qt.QDialogButtonBox()
self.buttonBox.standardButtons = self.standardButtons if getattr(self, "standardButtons") else \
qt.QDialogButtonBox.Ok | qt.QDialogButtonBox.Cancel
self.layout().addWidget(self.createHLayout(self.buttonBox.buttons()), 2, 0)
self.resize(int(slicer.util.mainWindow().width / 3 * 2), int(slicer.util.mainWindow().height / 4 * 3))
def setupConnections(self):
self.buttonBox.accepted.connect(lambda: self.accept())
self.buttonBox.rejected.connect(lambda: self.reject())
self.buttonBox.clicked.connect(lambda b: setattr(self, "clickedButton", self.buttonBox.standardButton(b)))
def setupSliceWidget(self):
try:
black = slicer.util.getNode('Black')
slicer.mrmlScene.RemoveNode(black)
except slicer.util.MRMLNodeNotFoundException:
pass
self.sliceNode = slicer.vtkMRMLSliceNode()
self.sliceNode.SetName("Black")
self.sliceNode.SetLayoutName("Black")
self.sliceNode.SetLayoutLabel("BL")
self.sliceNode.SetOrientationToAxial()
slicer.mrmlScene.AddNode(self.sliceNode)
self.sliceWidget = self.layoutManager.viewWidget(self.sliceNode)
self.sliceLogic = slicer.app.applicationLogic().GetSliceLogic(self.sliceNode)
self.sliceNode.SetMappedInLayout(1)
def exec_(self):
if not self.sliceNode.GetScene():
slicer.mrmlScene.AddNode(self.sliceNode)
self.sliceNode.SetMappedInLayout(1)
self.sliceLogic.GetSliceCompositeNode().SetBackgroundVolumeID(self.volumeNode.GetID())
if self.labelNode:
self.sliceLogic.GetSliceCompositeNode().SetLabelVolumeID(self.labelNode.GetID())
slicer.app.processEvents()
self.sliceLogic.FitSliceToAll()
self.sliceNode.RotateToVolumePlane(self.volumeNode)
qt.QDialog.exec_(self)
slicer.mrmlScene.RemoveNode(self.sliceNode)
return self.clickedButton
class SliceWidgetConfirmYesNoDialog(SliceWidgetDialogBase):
""" SliceWidgetConfirmYesNoDialog for displaying a slice widget with a specific question to confirm
.. code-block:: python
from SlicerDevelopmentToolboxUtils.widgets import SliceWidgetConfirmYesNoDialog
volume = ...
w = SliceWidgetConfirmYesNoDialog(volume, "Some random text")
w.exec_()
"""
def __init__(self, volume, text="", labelNode=None, parent=None, **kwargs):
super(SliceWidgetConfirmYesNoDialog, self).__init__(volume, text, labelNode, parent,
standardButtons=qt.QDialogButtonBox.Yes |
qt.QDialogButtonBox.No |
qt.QDialogButtonBox.Cancel, **kwargs)
class RadioButtonChoiceMessageBox(qt.QMessageBox, ModuleWidgetMixin):
""" MessageBox for displaying a message box giving the user a choice between different options.
.. code-block:: python
from SlicerDevelopmentToolboxUtils.widgets import RadioButtonChoiceMessageBox
mbox = RadioButtonChoiceMessageBox("Question?", options=["a", "b"])
mbox.exec_()
"""
def __init__(self, text, options, *args):
assert type(options) in [list, tuple] and len(options) > 1, "Valid types of 'options' are: list or tuple and needs" \
"to have at least two options"
qt.QMessageBox.__init__(self, *args)
self.standardButtons = qt.QMessageBox.Ok | qt.QMessageBox.Cancel
self.text = text
self.options = options
self._setup()
def __del__(self):
super(RadioButtonChoiceMessageBox, self).__del__()
for button in self.buttonGroup.buttons():
self._disconnectButton(button)
def show(self):
return self.exec_()
def reject(self):
qt.QMessageBox.reject(self)
def closeEvent(self, event):
qt.QMessageBox.closeEvent(self, event)
self.reject()
def exec_(self):
self.selectedOption = None
self.button(qt.QMessageBox.Ok).enabled = False
for b in self.buttonGroup.buttons():
self.buttonGroup.setExclusive(False)
b.checked = False
self.buttonGroup.setExclusive(True)
result = qt.QMessageBox.exec_(self)
if result == qt.QMessageBox.Ok:
return self.selectedOption
return None
def _setup(self):
self.buttonGroup = qt.QButtonGroup()
for optionId, option in enumerate(self.options):
button = self.createRadioButton(option)
button.setProperty('value', option)
button.setCursor(qt.Qt.PointingHandCursor)
self._connectButton(button)
self.buttonGroup.addButton(button, optionId)
col = self.createVLayout(list(self.buttonGroup.buttons()))
self.layout().addWidget(col, 1, 1)
def _connectButton(self, button):
button.clicked.connect(lambda: self._onOptionSelected(button.value))
def _disconnectButton(self, button):
button.clicked.disconnect(lambda: self._onOptionSelected(button.value))
def _onOptionSelected(self, value):
self.selectedOption = value
self.button(qt.QMessageBox.Ok).enabled = True
class TextInformationRequestDialog(qt.QDialog):
def __init__(self, attributeName, parent=None):
qt.QDialog.__init__(self, parent)
self._attributeName = attributeName
self.setup()
self._setupConnections()
def setup(self):
self.setLayout(qt.QGridLayout())
self._loadUI()
self.layout().addWidget(self.ui)
def _loadUI(self):
import inspect
modulePath = os.path.dirname(os.path.normpath(os.path.dirname(inspect.getfile(self.__class__))))
modulePath = modulePath.replace("SlicerDevelopmentToolboxUtils", "")
path = os.path.join(modulePath, 'Resources', 'UI', 'TextInformationRequestDialog.ui')
self.ui = slicer.util.loadUI(path)
self._lineEdit = self.ui.findChild(qt.QLineEdit, "lineEdit")
self._label = self.ui.findChild(qt.QLabel, "label")
self._label.setText(self._attributeName)
self._buttonBox = self.ui.findChild(qt.QDialogButtonBox, "buttonBox")
def _setupConnections(self):
def setupConnections(funcName="connect"):
getattr(self._buttonBox.accepted, funcName)(self.accept)
getattr(self._buttonBox.rejected, funcName)(self.reject)
getattr(self._lineEdit.textChanged, funcName)(self._onTextChanged)
setupConnections()
slicer.app.connect('aboutToQuit()', self.deleteLater)
self.destroyed.connect(lambda : setupConnections(funcName="disconnect"))
def _onTextChanged(self, text):
self._buttonBox.button(qt.QDialogButtonBox.Ok).enabled = bool(text.strip())
def getValue(self):
return self._lineEdit.text
| {"/SlicerDevelopmentToolboxUtils/buttons.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/widgets.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/helpers.py": ["/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/widgets.py": ["/SlicerDevelopmentToolboxUtils/constants.py", "/SlicerDevelopmentToolboxUtils/decorators.py", "/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/helpers.py", "/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/module/logic.py": ["/SlicerDevelopmentToolboxUtils/module/base.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py": ["/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py"], "/SlicerDevelopmentToolboxUtils/module/plugin.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/step.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/session.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/icons.py": ["/SlicerDevelopmentToolboxUtils/decorators.py"], "/SlicerDevelopmentToolboxUtils/forms/FormsDialog.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py"], "/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGenerator.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/module/base.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/decorators.py"]} |
50,122 | QIICR/SlicerDevelopmentToolbox | refs/heads/master | /SlicerDevelopmentToolboxUtils/module/logic.py | from .base import SessionBasedModuleBase, ModuleBase
from ..mixins import ModuleLogicMixin
class LogicBase(ModuleBase, ModuleLogicMixin):
def __init__(self):
ModuleBase.__init__(self)
class SessionBasedLogicBase(SessionBasedModuleBase, ModuleLogicMixin):
SessionClass = None
def __init__(self):
SessionBasedModuleBase.__init__(self) | {"/SlicerDevelopmentToolboxUtils/buttons.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/widgets.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/helpers.py": ["/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/widgets.py": ["/SlicerDevelopmentToolboxUtils/constants.py", "/SlicerDevelopmentToolboxUtils/decorators.py", "/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/helpers.py", "/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/module/logic.py": ["/SlicerDevelopmentToolboxUtils/module/base.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py": ["/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py"], "/SlicerDevelopmentToolboxUtils/module/plugin.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/step.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/session.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/icons.py": ["/SlicerDevelopmentToolboxUtils/decorators.py"], "/SlicerDevelopmentToolboxUtils/forms/FormsDialog.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py"], "/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGenerator.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/module/base.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/decorators.py"]} |
50,123 | QIICR/SlicerDevelopmentToolbox | refs/heads/master | /Testing/SlicerDevelopmentToolboxTests.py | import slicer
import os, shutil
import unittest
from threading import Thread
import time
from multiprocessing.dummy import Pool as ThreadPool
from SlicerDevelopmentToolboxUtils.helpers import DirectoryObserver
from SlicerDevelopmentToolboxUtils.mixins import ModuleLogicMixin
from SampleData import SampleDataLogic
__all__ = ['SlicerDevelopmentToolboxTests']
class DirectoryWatcherTest(unittest.TestCase, ModuleLogicMixin):
@classmethod
def setUpClass(cls):
slicer.mrmlScene.Clear(0)
cls.tempDir = slicer.app.temporaryPath
cls.watchedDirectory = os.path.join(cls.tempDir, "SlicerDevelopmentToolboxTesting", cls.__class__.__name__)
cls.createDirectory(cls.watchedDirectory)
cls.watcher = DirectoryObserver(cls.watchedDirectory)
cls.sampleDataLogic = SampleDataLogic()
cls.startedEventEmitted = False
cls.stoppedEventEmitted = False
cls.fileCountChangedEmitted = False
# def tearDown(self):
# shutil.rmtree(os.path.join(slicer.app.temporaryPath, "SlicerDevelopmentToolboxTesting"))
def runTest(self):
self.test_DirectoryWatcherEvents()
self.test_DirectoryWatcherStart()
self.test_DirectoryWatcherFileCountChanged()
self.test_DirectoryWatcherStop()
def test_DirectoryWatcherEvents(self):
self.watcher.addEventObserver(self.watcher.StartedEvent,
lambda event,caller:setattr(self, "startedEventEmitted", True))
self.watcher.addEventObserver(self.watcher.StoppedEvent,
lambda event,caller:setattr(self, "stoppedEventEmitted", True))
self.watcher.start()
self.watcher.stop()
self.watcher.removeEventObservers()
self.assertTrue(self.startedEventEmitted)
self.assertTrue(self.stoppedEventEmitted)
def test_DirectoryWatcherStart(self):
self.watcher.start()
self.assertTrue(self.watcher.isRunning())
def test_DirectoryWatcherFileCountChanged(self):
self.watcher.addEventObserver(self.watcher.FileCountChangedEvent,
lambda event,caller,callData:setattr(self, "fileCountChangedEmitted", True))
mrHead = self.sampleDataLogic.sourceForSampleName('MRHead')
self.sampleDataLogic.downloadFile(mrHead.uris[0], self.tempDir, mrHead.fileNames[0])
mrHeadPath = os.path.join(self.tempDir, mrHead.fileNames[0])
shutil.copy(mrHeadPath, os.path.join(self.watchedDirectory, mrHead.fileNames[0]))
def checkTimerExecuted():
while not self.fileCountChangedEmitted:
print "timer not done"
time.sleep(1)
print "timer done"
pool = ThreadPool(4)
results = pool.apply(checkTimerExecuted)
pool.close()
pool.join()
#
# t = Thread(target=checkTimerExecuted)
# t.start()
# t.run()
self.assertTrue(self.fileCountChangedEmitted)
self.watcher.removeEventObservers()
def print_time(self, threadName, delay):
count = 0
while count < 5:
time.sleep(delay)
count += 1
print "%s: %s" % (threadName, time.ctime(time.time()))
def test_DirectoryWatcherStop(self):
self.watcher.stop()
self.assertFalse(self.watcher.isRunning()) | {"/SlicerDevelopmentToolboxUtils/buttons.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/widgets.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/helpers.py": ["/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/widgets.py": ["/SlicerDevelopmentToolboxUtils/constants.py", "/SlicerDevelopmentToolboxUtils/decorators.py", "/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/helpers.py", "/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/module/logic.py": ["/SlicerDevelopmentToolboxUtils/module/base.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py": ["/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py"], "/SlicerDevelopmentToolboxUtils/module/plugin.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/step.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/session.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/icons.py": ["/SlicerDevelopmentToolboxUtils/decorators.py"], "/SlicerDevelopmentToolboxUtils/forms/FormsDialog.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py"], "/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGenerator.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/module/base.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/decorators.py"]} |
50,124 | QIICR/SlicerDevelopmentToolbox | refs/heads/master | /SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py | from __future__ import absolute_import
import os
from SlicerDevelopmentToolboxUtils.forms.JSONFormGenerator import JSONFormGenerator
class FormGeneratorFactory(object):
@staticmethod
def getFormGenerator(filePath):
fileName, fileExtension = os.path.splitext(filePath)
if fileExtension.lower() == '.json':
return JSONFormGenerator(filePath)
else:
raise ValueError("File extension %s is not supported right now" % fileExtension)
| {"/SlicerDevelopmentToolboxUtils/buttons.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/widgets.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/helpers.py": ["/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/widgets.py": ["/SlicerDevelopmentToolboxUtils/constants.py", "/SlicerDevelopmentToolboxUtils/decorators.py", "/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/helpers.py", "/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/module/logic.py": ["/SlicerDevelopmentToolboxUtils/module/base.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py": ["/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py"], "/SlicerDevelopmentToolboxUtils/module/plugin.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/step.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/session.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/icons.py": ["/SlicerDevelopmentToolboxUtils/decorators.py"], "/SlicerDevelopmentToolboxUtils/forms/FormsDialog.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py"], "/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGenerator.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/module/base.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/decorators.py"]} |
50,125 | QIICR/SlicerDevelopmentToolbox | refs/heads/master | /SlicerDevelopmentToolboxUtils/module/plugin.py | from .base import WidgetBase
class PluginBase(WidgetBase):
def __init__(self):
super(PluginBase, self).__init__() | {"/SlicerDevelopmentToolboxUtils/buttons.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/widgets.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/helpers.py": ["/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/widgets.py": ["/SlicerDevelopmentToolboxUtils/constants.py", "/SlicerDevelopmentToolboxUtils/decorators.py", "/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/helpers.py", "/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/module/logic.py": ["/SlicerDevelopmentToolboxUtils/module/base.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py": ["/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py"], "/SlicerDevelopmentToolboxUtils/module/plugin.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/step.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/session.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/icons.py": ["/SlicerDevelopmentToolboxUtils/decorators.py"], "/SlicerDevelopmentToolboxUtils/forms/FormsDialog.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py"], "/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGenerator.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/module/base.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/decorators.py"]} |
50,126 | QIICR/SlicerDevelopmentToolbox | refs/heads/master | /SlicerDevelopmentToolboxUtils/module/step.py | from .base import WidgetBase
class StepBase(WidgetBase):
def __init__(self):
super(StepBase, self).__init__()
| {"/SlicerDevelopmentToolboxUtils/buttons.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/widgets.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/helpers.py": ["/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/widgets.py": ["/SlicerDevelopmentToolboxUtils/constants.py", "/SlicerDevelopmentToolboxUtils/decorators.py", "/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/helpers.py", "/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/module/logic.py": ["/SlicerDevelopmentToolboxUtils/module/base.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py": ["/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py"], "/SlicerDevelopmentToolboxUtils/module/plugin.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/step.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/session.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/icons.py": ["/SlicerDevelopmentToolboxUtils/decorators.py"], "/SlicerDevelopmentToolboxUtils/forms/FormsDialog.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py"], "/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGenerator.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/module/base.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/decorators.py"]} |
50,127 | QIICR/SlicerDevelopmentToolbox | refs/heads/master | /SlicerDevelopmentToolboxUtils/forms/FormGenerator.py | from __future__ import absolute_import
from abc import abstractmethod, ABCMeta
import qt
class FormGenerator(metaclass=ABCMeta):
CustomFrameClass = None
def __init__(self, filePath):
self.filePath = filePath
if not self.CustomFrameClass:
raise NotImplementedError("All concrete classes need to implement member CustomFrameClass")
@abstractmethod
def generate(self):
pass
@abstractmethod
def _generate(self, data):
pass
def _createLabel(self, title, **kwargs):
label = qt.QLabel(title)
return self._extendQtGuiElementProperties(label, **kwargs)
def _createLineEdit(self, title, **kwargs):
lineEdit = qt.QLineEdit(title)
return self._extendQtGuiElementProperties(lineEdit, **kwargs)
def _createTextEdit(self, title, **kwargs):
textEdit = qt.QTextEdit(title)
return self._extendQtGuiElementProperties(textEdit, **kwargs)
def _createComboBox(self, **kwargs):
comboBox = qt.QComboBox()
return self._extendQtGuiElementProperties(comboBox, **kwargs)
def _extendQtGuiElementProperties(self, element, **kwargs):
for key, value in kwargs.items():
if hasattr(element, key):
setattr(element, key, value)
else:
import logging
logging.error("%s does not have attribute %s" % (element.className(), key))
return element
@classmethod
def _initializeCustomForm(cls):
form = cls.CustomFrameClass()
form.setLayout(qt.QFormLayout())
return form
class GeneratedFrame(qt.QFrame):
# TODO: it might make sense to use a design pattern here as well since users/developers
# might want to get the data in a different format
def __init__(self):
qt.QFrame.__init__(self)
def getData(self):
# TODO: iterate through ui elements and return as preferred format
pass
| {"/SlicerDevelopmentToolboxUtils/buttons.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/widgets.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/helpers.py": ["/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/widgets.py": ["/SlicerDevelopmentToolboxUtils/constants.py", "/SlicerDevelopmentToolboxUtils/decorators.py", "/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/helpers.py", "/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/module/logic.py": ["/SlicerDevelopmentToolboxUtils/module/base.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py": ["/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py"], "/SlicerDevelopmentToolboxUtils/module/plugin.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/step.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/session.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/icons.py": ["/SlicerDevelopmentToolboxUtils/decorators.py"], "/SlicerDevelopmentToolboxUtils/forms/FormsDialog.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py"], "/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGenerator.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/module/base.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/decorators.py"]} |
50,128 | QIICR/SlicerDevelopmentToolbox | refs/heads/master | /SlicerDevelopmentToolboxUtils/events.py | import vtk
class SlicerDevelopmentToolboxEvents(object):
NewImageDataReceivedEvent = vtk.vtkCommand.UserEvent + 100
NewFileIndexedEvent = vtk.vtkCommand.UserEvent + 101
StartedEvent = vtk.vtkCommand.UserEvent + 201
CanceledEvent = vtk.vtkCommand.UserEvent + 202
SkippedEvent = vtk.vtkCommand.UserEvent + 203
StoppedEvent = vtk.vtkCommand.UserEvent + 204
FinishedEvent = vtk.vtkCommand.UserEvent + 205
FailedEvent = vtk.vtkCommand.UserEvent + 206
SuccessEvent = vtk.vtkCommand.UserEvent + 207
FileCountChangedEvent = vtk.vtkCommand.UserEvent + 300
StatusChangedEvent = vtk.vtkCommand.UserEvent + 301 | {"/SlicerDevelopmentToolboxUtils/buttons.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/widgets.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/helpers.py": ["/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/widgets.py": ["/SlicerDevelopmentToolboxUtils/constants.py", "/SlicerDevelopmentToolboxUtils/decorators.py", "/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/helpers.py", "/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/module/logic.py": ["/SlicerDevelopmentToolboxUtils/module/base.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py": ["/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py"], "/SlicerDevelopmentToolboxUtils/module/plugin.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/step.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/session.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/icons.py": ["/SlicerDevelopmentToolboxUtils/decorators.py"], "/SlicerDevelopmentToolboxUtils/forms/FormsDialog.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py"], "/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGenerator.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/module/base.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/decorators.py"]} |
50,129 | QIICR/SlicerDevelopmentToolbox | refs/heads/master | /SlicerDevelopmentToolboxUtils/module/session.py | import shutil
import os
import logging
import vtk
from abc import ABCMeta, abstractmethod
from ..mixins import ModuleLogicMixin
from .base import ModuleBase
class SessionBase(ModuleBase, ModuleLogicMixin):
__metaclass__ = ABCMeta
DirectoryChangedEvent = vtk.vtkCommand.UserEvent + 203
NewCaseStartedEvent = vtk.vtkCommand.UserEvent + 501
CloseCaseEvent = vtk.vtkCommand.UserEvent + 502
CaseOpenedEvent = vtk.vtkCommand.UserEvent + 503
@property
def directory(self):
self._directory = getattr(self, "_directory", None)
return self._directory
@directory.setter
def directory(self, value):
if value:
if not os.path.exists(value):
self.createDirectory(value)
elif not value and self.directory:
if self.getDirectorySize(self._directory) == 0:
shutil.rmtree(self.directory)
self._directory = value
if self.directory:
self.processDirectory()
self.invokeEvent(self.DirectoryChangedEvent, self.directory)
def __init__(self, *args, **kwargs):
ModuleBase.__init__(self)
self._steps = []
@abstractmethod
def load(self):
pass
@abstractmethod
def processDirectory(self):
pass
@abstractmethod
def save(self):
pass
class StepBasedSession(SessionBase):
@property
def steps(self):
return self._steps
@steps.setter
def steps(self, value):
for step in self.steps:
step.removeSessionEventObservers()
self._steps = value
def __init__(self):
super(StepBasedSession, self).__init__()
def registerStep(self, step):
logging.debug("Registering step %s" % step.NAME)
if step not in self.steps:
self.steps.append(step)
def getStep(self, stepName):
return next((x for x in self.steps if x.NAME == stepName), None) | {"/SlicerDevelopmentToolboxUtils/buttons.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/widgets.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/helpers.py": ["/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/widgets.py": ["/SlicerDevelopmentToolboxUtils/constants.py", "/SlicerDevelopmentToolboxUtils/decorators.py", "/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/helpers.py", "/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/module/logic.py": ["/SlicerDevelopmentToolboxUtils/module/base.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py": ["/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py"], "/SlicerDevelopmentToolboxUtils/module/plugin.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/step.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/session.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/icons.py": ["/SlicerDevelopmentToolboxUtils/decorators.py"], "/SlicerDevelopmentToolboxUtils/forms/FormsDialog.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py"], "/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGenerator.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/module/base.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/decorators.py"]} |
50,130 | QIICR/SlicerDevelopmentToolbox | refs/heads/master | /SlicerDevelopmentToolboxUtils/icons.py | import os
import inspect
import qt
import re
from SlicerDevelopmentToolboxUtils.decorators import classproperty
class IconsMetaClass(type):
""" IconMetaClass searches the Resources/Icons directory for png files starting with 'icon-' and provides class members
No code needs to be changed when adding a new icon. The filename of the icon should look as follows:
'icon-'...'.png'. Capital letters will be transformed to lower case and '-' and ' ' will be replaced with '_'
Examples:
icon-fiducial-add.png --> Icons.fiducial_add
icon-cursor-WindowLevel.png --> Icons.cursor_window_level
icon-layout-OneUpRedSliceView.png --> Icons.layout_one_up_red_slice_view
Note:
This class is used as a metaclass
"""
@classproperty
def _getDictionaryFromDirectory(cls):
modulePath = os.path.dirname(os.path.normpath(os.path.dirname(inspect.getfile(cls))))
resourcesPath = os.path.join(modulePath, 'Resources/Icons')
dictionary = dict()
for filename in os.listdir(resourcesPath):
if not filename.startswith("icon-") or not filename.endswith(".png"):
continue
name = filename.replace("icon-", "").replace(".png", "").replace("-", "_").replace(" ", "_")
name = re.sub('(?<!^)(?=[A-Z])', '_', name).lower().replace("__", "_")
dictionary[name] = filename
return dictionary
_ICONS = _getDictionaryFromDirectory
@classmethod
def getIcon(cls, name):
""" Returning a QIcon for the retrieved icon name. Throws an exception if the name was not found.
"""
if not name in cls._ICONS.keys():
raise ValueError("Attribute %s is not defined." % name)
return qt.QIcon(cls.getPath(name))
@classmethod
def getPath(cls, name):
""" Returns the path to a specific icon. """
modulePath = os.path.dirname(os.path.normpath(os.path.dirname(inspect.getfile(cls))))
return os.path.join(modulePath, 'Resources/Icons', cls._ICONS[name])
def __getattr__(cls, attr):
if not attr in cls._ICONS.keys():
raise AttributeError("Attribute %s is not defined." % attr)
icon = cls.getIcon(attr)
setattr(cls, attr, icon)
return getattr(cls, attr)
class Icons(object, metaclass=IconsMetaClass):
""" The Icons class provides a bunch of frequently used icons.
All icons from ``names`` can directly be accessed by using ``Icons.{name from names list}`` (i.e. ``Icons.apply``)
.. code-block:: python
from SlicerDevelopmentToolboxUtils.icons import Icons
Icons.names
# a icon can be retrieved by calling Icons.{name}
applyIcon = Icons.apply
sideBySideIcon = Icons.layout_side_by_side_view
"""
@classproperty
def names(cls):
return sorted(cls._ICONS.keys())
@classmethod
def getPath(cls, name):
return IconsMetaClass.getPath(cls, name)
| {"/SlicerDevelopmentToolboxUtils/buttons.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/widgets.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/helpers.py": ["/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/widgets.py": ["/SlicerDevelopmentToolboxUtils/constants.py", "/SlicerDevelopmentToolboxUtils/decorators.py", "/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/helpers.py", "/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/module/logic.py": ["/SlicerDevelopmentToolboxUtils/module/base.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py": ["/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py"], "/SlicerDevelopmentToolboxUtils/module/plugin.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/step.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/session.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/icons.py": ["/SlicerDevelopmentToolboxUtils/decorators.py"], "/SlicerDevelopmentToolboxUtils/forms/FormsDialog.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py"], "/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGenerator.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/module/base.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/decorators.py"]} |
50,131 | QIICR/SlicerDevelopmentToolbox | refs/heads/master | /SlicerDevelopmentToolboxUtils/forms/FormsDialog.py | from __future__ import absolute_import
import qt
import os
import slicer
from SlicerDevelopmentToolboxUtils.forms.FormGeneratorFactory import FormGeneratorFactory
class FormsDialog(qt.QDialog):
@property
def currentForm(self):
return self._currentForm
@currentForm.setter
def currentForm(self, form):
if self._currentForm is not None:
self._currentForm.form.setParent(None)
self._uiLayout.removeWidget(self._currentForm.form)
self._currentForm = form
if self._currentForm:
self._uiLayout.addWidget(form.form, 1, 1)
self.updateNavigationButtons()
self.onResize()
def __init__(self, schemaFiles, defaultSettings=None, parent=None):
qt.QDialog.__init__(self, parent)
self._defaultSettings = defaultSettings
self.logic = FormsDialogLogic(schemaFiles)
self.formWidgets = list()
self.setup()
self._setupConnections()
def setup(self):
self.setLayout(qt.QGridLayout())
self._loadUI()
self.generateFormWidgets()
self.currentForm = self.formWidgets[0]
self.updateNavigationButtons()
self.layout().addWidget(self.ui)
def onResize(self, caller=None, event=None):
slicer.app.processEvents()
self.adjustSize()
def _loadUI(self):
import inspect
modulePath = os.path.dirname(os.path.normpath(os.path.dirname(inspect.getfile(self.__class__))))
modulePath = modulePath.replace("SlicerDevelopmentToolboxUtils", "")
path = os.path.join(modulePath, 'Resources', 'UI', 'FormsDialog.ui')
self.ui = slicer.util.loadUI(path)
self._uiLayout = self.ui.findChild(qt.QGridLayout, "gridLayout")
self._prevButton = self.ui.findChild(qt.QPushButton, "prevButton")
self._nextButton = self.ui.findChild(qt.QPushButton, "nextButton")
self._buttonBox = self.ui.findChild(qt.QDialogButtonBox, "buttonBox")
self._navigationBar = self.ui.findChild(qt.QWidget, "navigationBar")
def _setupConnections(self):
def setupConnections(funcName="connect"):
getattr(self._buttonBox.accepted, funcName)(self._onAccept)
getattr(self._buttonBox.rejected, funcName)(self._onReject)
getattr(self._prevButton.clicked, funcName)(self._onPrevButtonClicked)
getattr(self._nextButton.clicked, funcName)(self._onNextButtonClicked)
setupConnections()
slicer.app.connect('aboutToQuit()', self.deleteLater)
self.destroyed.connect(lambda : setupConnections(funcName="disconnect"))
def updateNavigationButtons(self):
self._prevButton.setEnabled(self._currentForm is not None and self._currentForm.hasPrev())
self._nextButton.setEnabled(self._currentForm is not None and self._currentForm.hasNext())
def _onPrevButtonClicked(self):
self.currentForm = self._currentForm.prevForm
def _onNextButtonClicked(self):
self.currentForm = self._currentForm.nextForm
def _onAccept(self):
# persist data for forms
self.accept()
def _onReject(self):
self.reject()
def generateFormWidgets(self):
self._currentForm = None
for form in self.logic.schemaFiles:
gen = FormGeneratorFactory.getFormGenerator(form)
newForm = DoublyLinkedForms(gen.generate(self._defaultSettings))
newForm.form.addEventObserver(newForm.form.ResizeEvent, self.onResize)
newForm.form.addEventObserver(newForm.form.ValidEvent, lambda caller, event: self._validateForms())
newForm.form.addEventObserver(newForm.form.InvalidEvent, self._onInvalidFormFound)
self.formWidgets.append(newForm)
if self._currentForm:
newForm.prevForm = self._currentForm
self._currentForm.nextForm = newForm
self._currentForm = newForm
self._navigationBar.visible = len(self.logic.schemaFiles) > 1
def getData(self, hideTopLevelTitle=True):
data = dict()
for form in self.formWidgets:
data.update(form.form.getData(hideTopLevelTitle))
return data
def _onInvalidFormFound(self, caller, event):
self._buttonBox.button(qt.QDialogButtonBox.Ok).enabled = False
def _validateForms(self):
self._buttonBox.button(qt.QDialogButtonBox.Ok).enabled = all(f.form.isValid() is True for f in self.formWidgets)
def exec_(self):
self._validateForms()
return qt.QDialog.exec_(self)
class FormsDialogLogic(object):
@property
def schemaFiles(self):
return self._schemaFiles
@schemaFiles.setter
def schemaFiles(self, schemaFiles):
if type(schemaFiles) is str:
schemaFiles = [schemaFiles]
elif type(schemaFiles) is list:
pass
else:
raise ValueError("Value %s is not valid for schema files. It has to be either a list or a string" % schemaFiles)
self._schemaFiles = schemaFiles
def __init__(self, schemaFiles):
self.schemaFiles = schemaFiles
class DoublyLinkedForms(object):
def __init__(self, form):
self.form = form
self.nextForm = None
self.prevForm = None
def hasNext(self):
return self.nextForm is not None
def hasPrev(self):
return self.prevForm is not None
| {"/SlicerDevelopmentToolboxUtils/buttons.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/widgets.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/helpers.py": ["/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/widgets.py": ["/SlicerDevelopmentToolboxUtils/constants.py", "/SlicerDevelopmentToolboxUtils/decorators.py", "/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/helpers.py", "/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/module/logic.py": ["/SlicerDevelopmentToolboxUtils/module/base.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py": ["/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py"], "/SlicerDevelopmentToolboxUtils/module/plugin.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/step.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/session.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/icons.py": ["/SlicerDevelopmentToolboxUtils/decorators.py"], "/SlicerDevelopmentToolboxUtils/forms/FormsDialog.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py"], "/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGenerator.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/module/base.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/decorators.py"]} |
50,132 | QIICR/SlicerDevelopmentToolbox | refs/heads/master | /SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py | from __future__ import absolute_import
import vtk
import ctk
import json
from collections import OrderedDict
from SlicerDevelopmentToolboxUtils.forms.FormGenerator import *
from SlicerDevelopmentToolboxUtils.mixins import UICreationHelpers, GeneralModuleMixin
# TODO: definitions are not resolved right now
class JSONFormGenerator(FormGenerator):
CustomFrameClass = GeneratedFrame
def generate(self, defaultSettings=None):
with open(self.filePath) as data_file:
data = json.load(data_file, object_pairs_hook=OrderedDict)
return self._generate(data, defaultSettings)
def _generate(self, schema, defaultSettings=None):
return JSONObjectField("", schema, defaultSettings=defaultSettings, addRestoreDefaultsButton=True)
class JSONFieldFactory(object):
@staticmethod
def getJSONFieldClass(schema):
dataType = schema.get('type')
if dataType == "object":
return JSONObjectField
elif "enum" in schema:
return JSONEnumField
else:
if dataType == "string":
return JSONStringField
elif dataType == "integer":
return JSONIntegerField
elif dataType == "number":
return JSONNumberField
# elif dataType == "array":
# return JSONArrayField
raise ValueError("Schema %s cannot be handled by %s" % (schema, JSONFieldFactory.__name__))
class AbstractField(GeneralModuleMixin):
UpdateEvent = vtk.vtkCommand.UserEvent + 100
ResizeEvent = vtk.vtkCommand.UserEvent + 101
InvalidEvent = vtk.vtkCommand.UserEvent + 102
ValidEvent = vtk.vtkCommand.UserEvent + 103
def __init__(self, schema, required=False, defaultSettings=None):
self._defaultSettings = defaultSettings
self._type = schema.get('type')
self._schema = schema
self.required = required
self.setup()
def setup(self):
return NotImplementedError
def getData(self):
return NotImplementedError
def setData(self, data):
# TODO: needs to iterate trough objects etc.
# editable?
raise NotImplementedError
def execAndGetReturnValue(self, code):
code = code.replace("callback:", "")
commands = list(filter((lambda x: len(x) > 0), code.split(';')))
_locals = locals()
for idx, command in enumerate(commands):
if idx == len(commands)-1:
break
exec(command, _locals)
exec("returnValue={}".format(commands[-1]), _locals)
return _locals['returnValue']
def isValid(self):
raise NotImplementedError
def restoreJSONDefaults(self):
raise NotImplementedError
class AbstractFieldWidget(qt.QWidget, AbstractField):
def __init__(self, title, schema, required=False, defaultSettings=None, parent=None):
self._elem = None
self._data = dict()
self.title = title
qt.QWidget.__init__(self, parent)
AbstractField.__init__(self, schema, required, defaultSettings)
def getDefaultValue(self):
value = None
if self._defaultSettings:
value = self._defaultSettings.value(self.title)
if not value and self._schema.get("default"):
value = self._schema["default"]
value = self.execAndGetReturnValue(value) if type(value) == str and "callback:" in value else value
return value
def getDefaultJSONValue(self):
return self._schema.get("default")
def getData(self):
return self._data
def getElement(self):
return self._elem
def _updateData(self, key, value):
try:
value = JSONTypeConverter.getPythonType(self._type)(value)
except ValueError:
value = None
if not value:
self._data.pop(key, None)
else:
self._data[key] = value
if self.required and not value:
self.invokeEvent(self.InvalidEvent)
else:
self.invokeEvent(self.UpdateEvent, str([key, value]))
self.invokeEvent(self.ValidEvent)
def restoreJSONDefaults(self):
value = self._elem.property("default")
self._elem.setText(self.execAndGetReturnValue(value) if type(value) == str and "callback:" in value else value)
class JSONObjectField(qt.QWidget, AbstractField):
@property
def title(self):
if self._subWidget:
return getattr(self._subWidget, "title" if isinstance(self._subWidget, qt.QGroupBox) else "text")
return self._title
@title.setter
def title(self, value):
if not self._subWidget:
self._title = value
else:
setattr(self._subWidget, "title" if isinstance(self._subWidget, qt.QGroupBox) else "text", value)
def __init__(self, title, schema, required=False, defaultSettings=None, addRestoreDefaultsButton=False, parent=None):
self.elements = []
self._subWidget = None
self.title = title
self._addRestoreDefaultsButton = addRestoreDefaultsButton
qt.QWidget.__init__(self, parent)
AbstractField.__init__(self, schema, required, defaultSettings)
def setup(self):
self.setLayout(qt.QVBoxLayout())
schema = self._schema
self._setupSubWidget()
requiredElements = []
if self._schema.get("description"):
self.setToolTip(self._schema["description"])
if self._schema.get('properties'):
schema = self._schema['properties']
if self._schema.get('required'):
requiredElements = self._schema['required']
for title, obj in list(schema.items()):
fieldObjectClass = JSONFieldFactory.getJSONFieldClass(obj)
self._addElement(fieldObjectClass(title, obj,
required=title in requiredElements, defaultSettings=self._defaultSettings))
self.setSizePolicy(qt.QSizePolicy.Expanding, qt.QSizePolicy.Expanding)
def _setupSubWidget(self):
if self._schema.get("collapsible") is True:
self._subWidget = ctk.ctkCollapsibleButton()
if self._schema.get("collapsed"):
self._subWidget.collapsed = self._schema.get("collapsed")
self._subWidget.contentsCollapsed.connect(self.onCollapsed)
else:
self._subWidget = qt.QGroupBox(self._title)
self.title = self._schema.get("title") if self._schema.get("title") else self._title
self._subWidget.setLayout(qt.QFormLayout())
self.layout().addWidget(self._subWidget)
if self._addRestoreDefaultsButton:
self._restoreDefaultsButton = UICreationHelpers.createButton("Restore defaults")
self.layout().addWidget(self._restoreDefaultsButton)
self._restoreDefaultsButton.clicked.connect(self.restoreJSONDefaults)
def onCollapsed(self, collapsed):
qt.QTimer.singleShot(50, lambda: self.invokeEvent(self.ResizeEvent))
def _addElement(self, elem):
if isinstance(elem, JSONObjectField):
self._subWidget.layout().addWidget(elem)
elem.addEventObserver(self.ResizeEvent, lambda caller, event: self.invokeEvent(self.ResizeEvent))
else:
self._subWidget.layout().addRow(elem.title, elem)
if elem.required:
elem.addEventObserver(self.InvalidEvent, lambda caller, event: self.invokeEvent(self.InvalidEvent))
elem.addEventObserver(self.ValidEvent, self._onValid)
self.elements.append(elem)
def _onValid(self, caller, event):
self.invokeEvent(self.ValidEvent if self.isValid() else self.InvalidEvent)
def getData(self, hideTopLevelTitle=False):
""" Returns non empty data entered by the user. Parameter `hideTopLevelTitle` hides title of the top level object
An example is displayed below showing that the top level object has a title which might not be of interest when
retrieving entered data
Example:
{ "type": "object",
"title": "Patient Clinical Information",
"properties": {
...
}
"""
data = dict()
for elem in self.elements:
data.update(elem.getData())
return data if not self.title or hideTopLevelTitle else {self.title: data}
def isValid(self):
return all(elem.isValid() is True for elem in self.elements)
def restoreJSONDefaults(self):
for elem in self.elements:
elem.restoreJSONDefaults()
class JSONArrayField(qt.QGroupBox, AbstractField):
# TODO implement
pass
class JSONEnumField(AbstractFieldWidget):
def setup(self):
self.setLayout(qt.QFormLayout())
widgetClass = self._schema.get("ui:widget", "combo")
if widgetClass == "radio":
self._elem = self.__setupRadioButtonGroup()
else:
self._elem = self.__setupComboBox()
if self._schema.get("description"):
self._elem.setToolTip(self._schema["description"])
self.layout().addWidget(self._elem)
def __setupComboBox(self):
elem = qt.QComboBox()
elem.connect("currentIndexChanged(QString)",
lambda text: self._updateData(self.title, text))
self.destroyed.connect(lambda: elem.disconnect("currentIndexChanged(QString)"))
elem.addItems(self._schema["enum"])
return elem
def __setupRadioButtonGroup(self):
elem = qt.QFrame()
elem.setLayout(qt.QVBoxLayout())
self.__buttonGroup = qt.QButtonGroup()
self.__buttonGroup.setExclusive(True)
self.__buttonGroup.connect("buttonClicked(QAbstractButton*)",
lambda button: self._updateData(self.title, button.text))
self.destroyed.connect(lambda: self.__buttonGroup.disconnect("buttonClicked(QAbstractButton*)"))
for e in self._schema["enum"]:
b = UICreationHelpers.createRadioButton(e, name=e)
elem.layout().addWidget(b)
self.__buttonGroup.addButton(b)
return elem
def isValid(self):
if not self.required:
return True
if isinstance(self._elem, qt.QComboBox):
return bool(self._elem.currentText.strip())
else:
return self.__buttonGroup.checkedButton() is not None
class JSONStringField(AbstractFieldWidget):
def setup(self):
self.setLayout(qt.QFormLayout())
widgetClass = self._schema.get("ui:widget", "line")
if widgetClass == "textarea":
self._elem = self._setupTextArea()
else:
self._elem = self._setupLineEdit()
self._configureAdditionalElementAttributes()
self.layout().addWidget(self._elem)
def _configureAdditionalElementAttributes(self):
if self._schema.get("maxLength"):
self._elem.setMaxLength(self._schema["maxLength"])
default = self.getDefaultValue()
if default:
self._elem.setText(default)
self._elem.setProperty('default', self.getDefaultJSONValue())
if self._schema.get("description"):
self._elem.setToolTip(self._schema["description"])
self.destroyed.connect(lambda: self._elem.textChanged.disconnect())
def _setupTextArea(self):
elem = qt.QTextEdit()
elem.textChanged.connect(lambda: self._updateData(self.title, elem.toPlainText()))
return elem
def _setupLineEdit(self):
# has pattern?
elem = qt.QLineEdit()
elem.textChanged.connect(lambda text: self._updateData(self.title, text))
return elem
def isValid(self):
if not self.required:
return True
if isinstance(self._elem, qt.QTextEdit):
return bool(self._elem.toPlainText().strip())
else:
return bool(self._elem.text.strip())
class JSONNumberField(AbstractFieldWidget):
validatorClass = qt.QDoubleValidator
def setup(self):
self.setLayout(qt.QFormLayout())
self._configureValidator()
self._elem = qt.QLineEdit()
self._connectField()
self._elem.setValidator(self._validator)
default = self.getDefaultValue()
if default:
self._elem.setText(default)
self._elem.setProperty('default', self.getDefaultJSONValue())
if self._schema.get("description"):
self._elem.setToolTip(self._schema["description"])
self.layout().addWidget(self._elem)
def _connectField(self):
self._elem.textChanged.connect(lambda n: self._updateData(self.title, n))
self.destroyed.connect(lambda: self._elem.textChanged.disconnect())
def _configureValidator(self):
self._validator = self.validatorClass()
if self._schema.get("minimum"):
self._validator.setBottom(self._schema.get("minimum"))
if self._schema.get("maximum"):
self._validator.setTop(self._schema.get("maximum"))
return self._validator
def isValid(self):
if not self.required:
return True
return bool(str(self._elem.value).strip())
class JSONIntegerField(JSONNumberField):
validatorClass = qt.QIntValidator
def _connectField(self):
self._elem.textChanged.connect(lambda n: self._updateData(self.title, n))
self.destroyed.connect(lambda: self._elem.textChanged.disconnect())
class JSONTypeConverter(object):
@staticmethod
def getPythonType(jsonType):
if jsonType == 'number':
return float
elif jsonType == 'integer':
return int
elif jsonType == 'string':
return str
elif jsonType == 'boolean':
return bool
return None
| {"/SlicerDevelopmentToolboxUtils/buttons.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/widgets.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/helpers.py": ["/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/widgets.py": ["/SlicerDevelopmentToolboxUtils/constants.py", "/SlicerDevelopmentToolboxUtils/decorators.py", "/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/helpers.py", "/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/module/logic.py": ["/SlicerDevelopmentToolboxUtils/module/base.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py": ["/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py"], "/SlicerDevelopmentToolboxUtils/module/plugin.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/step.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/session.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/icons.py": ["/SlicerDevelopmentToolboxUtils/decorators.py"], "/SlicerDevelopmentToolboxUtils/forms/FormsDialog.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py"], "/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGenerator.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/module/base.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/decorators.py"]} |
50,133 | QIICR/SlicerDevelopmentToolbox | refs/heads/master | /SlicerDevelopmentToolbox.py | import slicer
from slicer.ScriptedLoadableModule import *
import SlicerDevelopmentToolboxUtils
class SlicerDevelopmentToolboxClass(object):
def __init__(self):
pass
class SlicerDevelopmentToolbox(ScriptedLoadableModule):
"""
This class is the 'hook' for slicer to detect and recognize the plugin
as a loadable scripted module
"""
def __init__(self, parent):
ScriptedLoadableModule.__init__(self, parent)
parent.title = "SlicerDevelopmentToolbox Utils"
parent.categories = ["Developer Tools.Utils"]
parent.hidden = True
parent.contributors = ["Christian Herz (SPL), Andrey Fedorov (SPL)"]
parent.helpText = """
This class represents a hidden module which includes a lot of useful
widgets, helpers, constants, decorators, mixins, metaclasses and icons.
No module interface here.
"""
parent.acknowledgementText = """
These SlicerDevelopmentToolbox utils were developed by
Christian Herz, SPL
"""
slicer.modules.slicerSDT = SlicerDevelopmentToolboxClass | {"/SlicerDevelopmentToolboxUtils/buttons.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/widgets.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/helpers.py": ["/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/widgets.py": ["/SlicerDevelopmentToolboxUtils/constants.py", "/SlicerDevelopmentToolboxUtils/decorators.py", "/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/helpers.py", "/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/module/logic.py": ["/SlicerDevelopmentToolboxUtils/module/base.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py": ["/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py"], "/SlicerDevelopmentToolboxUtils/module/plugin.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/step.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/session.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/icons.py": ["/SlicerDevelopmentToolboxUtils/decorators.py"], "/SlicerDevelopmentToolboxUtils/forms/FormsDialog.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py"], "/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGenerator.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/module/base.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/decorators.py"]} |
50,134 | QIICR/SlicerDevelopmentToolbox | refs/heads/master | /SlicerDevelopmentToolboxUtils/module/base.py | import os
import logging
import vtk
import qt
import slicer
from ..mixins import GeneralModuleMixin, ModuleWidgetMixin
from ..decorators import onModuleSelected
class ModuleBase(GeneralModuleMixin):
MODULE_NAME = None
@property
def resourcesPath(self):
return os.path.join(self.modulePath, "Resources")
def __init__(self):
if not self.MODULE_NAME:
raise NotImplementedError("Member MODULE_NAME needs to be defined in order to get the module path and resources")
self.modulePath = self.getModulePath()
self.addMrmlSceneClearObserver()
def __del__(self):
super(ModuleBase, self).__del__()
self.cleanup()
def addMrmlSceneClearObserver(self):
@onModuleSelected(self.MODULE_NAME)
def onMrmlSceneCleared(caller, event):
logging.debug("called onMrmlSceneCleared in %s" % self.__class__.__name__)
self.onMrmlSceneCleared(caller, event)
self.mrmlSceneObserver = slicer.mrmlScene.AddObserver(slicer.mrmlScene.EndCloseEvent, onMrmlSceneCleared)
def onMrmlSceneCleared(self, caller, event):
pass
def cleanup(self):
if self.mrmlSceneObserver:
self.mrmlSceneObserver = slicer.mrmlScene.RemoveObserver(self.mrmlSceneObserver)
def getModulePath(self):
return os.path.dirname(slicer.util.modulePath(self.MODULE_NAME))
def getSetting(self, setting, moduleName=None, default=None):
return GeneralModuleMixin.getSetting(self, setting, moduleName=moduleName if moduleName else self.MODULE_NAME,
default=default)
def setSetting(self, setting, value, moduleName=None):
return GeneralModuleMixin.setSetting(self, setting, value,
moduleName=moduleName if moduleName else self.MODULE_NAME)
class SessionBasedModuleBase(ModuleBase):
SessionClass = None
def __init__(self):
super(SessionBasedModuleBase, self).__init__()
if not self.SessionClass:
raise NotImplementedError("Member SessionClass needs to be defined.")
self.session = self.SessionClass()
class WidgetBase(qt.QWidget, SessionBasedModuleBase, ModuleWidgetMixin):
NAME = None
ActivatedEvent = vtk.vtkCommand.UserEvent + 150
DeactivatedEvent = vtk.vtkCommand.UserEvent + 151
LogicClass = None
LayoutClass = qt.QGridLayout
@property
def currentResult(self):
return self.session.currentResult
@currentResult.setter
def currentResult(self, value):
self.session.currentResult = value
@property
def active(self):
self._activated = getattr(self, "_activated", False)
return self._activated
@active.setter
def active(self, value):
if self.active == value:
return
self._activated = value
logging.debug("%s %s" % ("activated" if self.active else "deactivate", self.NAME))
self.invokeEvent(self.ActivatedEvent if self.active else self.DeactivatedEvent)
if self.active:
self.onActivation()
else:
self.onDeactivation()
def __init__(self):
qt.QWidget.__init__(self)
SessionBasedModuleBase.__init__(self)
if not self.NAME:
raise NotImplementedError("NAME needs to be defined for each widget based class")
self._plugins = []
if self.LogicClass:
self.logic = self.LogicClass()
self.setLayout(self.LayoutClass())
self.setupIcons()
self.setup()
self.addSessionObservers()
self.setupConnections()
def __del__(self):
self.removeSessionEventObservers()
def setupIcons(self):
pass
def setup(self):
NotImplementedError("This method needs to be implemented for %s" % self.NAME)
def setupConnections(self):
NotImplementedError("This method needs to be implemented for %s" % self.NAME)
def addSessionObservers(self):
self.session.addEventObserver(self.session.NewCaseStartedEvent, self.onNewCaseStarted)
self.session.addEventObserver(self.session.CaseOpenedEvent, self.onCaseOpened)
self.session.addEventObserver(self.session.CloseCaseEvent, self.onCaseClosed)
def removeSessionEventObservers(self):
self.session.removeEventObserver(self.session.NewCaseStartedEvent, self.onNewCaseStarted)
self.session.removeEventObserver(self.session.CaseOpenedEvent, self.onCaseOpened)
self.session.removeEventObserver(self.session.CloseCaseEvent, self.onCaseClosed)
def onActivation(self):
self._activatePlugins()
def onDeactivation(self):
self._deactivatePlugins()
def onNewCaseStarted(self, caller, event):
pass
def onCaseOpened(self, caller, event):
pass
@vtk.calldata_type(vtk.VTK_STRING)
def onCaseClosed(self, caller, event, callData):
pass
def _activatePlugins(self):
self.__setPluginsActivated(True)
def _deactivatePlugins(self):
self.__setPluginsActivated(False)
def __setPluginsActivated(self, activated):
for plugin in self._plugins:
plugin.active = activated
def addPlugin(self, plugin):
assert hasattr(plugin, "active"), "Plugin needs to be a subclass of %s" % WidgetBase.__class__.__name__
self._plugins.append(plugin) | {"/SlicerDevelopmentToolboxUtils/buttons.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/widgets.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/helpers.py": ["/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/widgets.py": ["/SlicerDevelopmentToolboxUtils/constants.py", "/SlicerDevelopmentToolboxUtils/decorators.py", "/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/helpers.py", "/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/module/logic.py": ["/SlicerDevelopmentToolboxUtils/module/base.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py": ["/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py"], "/SlicerDevelopmentToolboxUtils/module/plugin.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/step.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/session.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/icons.py": ["/SlicerDevelopmentToolboxUtils/decorators.py"], "/SlicerDevelopmentToolboxUtils/forms/FormsDialog.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py"], "/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGenerator.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/module/base.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/decorators.py"]} |
50,135 | QIICR/SlicerDevelopmentToolbox | refs/heads/master | /SlicerDevelopmentToolboxUtils/mixins.py | import qt, vtk, ctk
import os, logging
import slicer
import SimpleITK as sitk
import sitkUtils
import pydicom
class ParameterNodeObservationMixin(object):
"""
This class can be used as a mixin for all classes that provide a method getParameterNode like
ScriptedLoadableModuleLogic. ParameterNodeObservationMixin provides the possibility to simply
observe the parameter node. Custom events can be observed and from your ScriptedLoadableModuleLogic
invoked. Originated was this class from slicer.util.VTKObservationMixin
"""
def __del__(self):
self.removeEventObservers()
@property
def parameterNode(self):
try:
return self._parameterNode
except AttributeError:
self._parameterNode = self.getParameterNode() if hasattr(self, "getParameterNode") else self._createParameterNode()
return self._parameterNode
@property
def parameterNodeObservers(self):
try:
return self._parameterNodeObservers
except AttributeError:
self._parameterNodeObservers = []
return self._parameterNodeObservers
def _createParameterNode(self):
parameterNode = slicer.vtkMRMLScriptedModuleNode()
slicer.mrmlScene.AddNode(parameterNode)
return parameterNode
def removeEventObservers(self, method=None):
for e, m, g, t in list(self.parameterNodeObservers):
if method == m or method is None:
self.parameterNode.RemoveObserver(t)
self.parameterNodeObservers.remove([e, m, g, t])
def addEventObserver(self, event, method, group='none'):
if self.hasEventObserver(event, method):
self.removeEventObserver(event, method)
tag = self.parameterNode.AddObserver(event, method)
self.parameterNodeObservers.append([event, method, group, tag])
def removeEventObserver(self, event, method):
for e, m, g, t in self.parameterNodeObservers:
if e == event and m == method:
self.parameterNode.RemoveObserver(t)
self.parameterNodeObservers.remove([e, m, g, t])
def hasEventObserver(self, event, method):
for e, m, g, t in self.parameterNodeObservers:
if e == event and m == method:
return True
return False
def invokeEvent(self, event, callData=None):
if callData:
self.parameterNode.InvokeEvent(event, callData)
else:
self.parameterNode.InvokeEvent(event)
def getEventObservers(self):
observerMethodDict = {}
for e, m, g, t in self.parameterNodeObservers:
observerMethodDict[e] = m
return observerMethodDict
class GeneralModuleMixin(ParameterNodeObservationMixin):
def _processKwargs(self, **kwargs):
for key, value in iter(kwargs.items()):
if hasattr(self, key):
setattr(self, key, value)
@staticmethod
def getSlicerErrorLogPath():
return slicer.app.errorLogModel().filePath
@staticmethod
def getTime():
import datetime
d = datetime.datetime.now()
return d.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-4] + "Z"
def hasSetting(self, setting, moduleName=None):
moduleName = moduleName if moduleName else self.moduleName
settings = qt.QSettings()
return settings.contains(moduleName + '/' + setting)
def getSetting(self, setting, moduleName=None, default=None):
moduleName = moduleName if moduleName else self.moduleName
settings = qt.QSettings()
setting = settings.value(moduleName + '/' + setting)
return setting if setting is not None else default
def setSetting(self, setting, value, moduleName=None):
moduleName = moduleName if moduleName else self.moduleName
settings = qt.QSettings()
settings.setValue(moduleName + '/' + setting, value)
def removeSetting(self, setting, moduleName=None):
moduleName = moduleName if moduleName else self.moduleName
settings = qt.QSettings()
settings.remove(moduleName+ '/' + setting)
@staticmethod
def createTimer(interval, slot, singleShot=False):
timer = qt.QTimer()
timer.setInterval(interval)
timer.timeout.connect(slot)
timer.setSingleShot(singleShot)
return timer
class UICreationHelpers(object):
@staticmethod
def createSliderWidget(minimum, maximum):
slider = slicer.qMRMLSliderWidget()
slider.minimum = minimum
slider.maximum = maximum
return slider
@staticmethod
def createLabel(title, **kwargs):
label = qt.QLabel(title)
return UICreationHelpers.extendQtGuiElementProperties(label, **kwargs)
@staticmethod
def createLineEdit(title, **kwargs):
lineEdit = qt.QLineEdit(title)
return UICreationHelpers.extendQtGuiElementProperties(lineEdit, **kwargs)
@staticmethod
def createButton(title, buttonClass=qt.QPushButton, **kwargs):
button = buttonClass(title)
button.setCursor(qt.Qt.PointingHandCursor)
return UICreationHelpers.extendQtGuiElementProperties(button, **kwargs)
@staticmethod
def createRadioButton(text, **kwargs):
button = qt.QRadioButton(text)
button.setCursor(qt.Qt.PointingHandCursor)
return UICreationHelpers.extendQtGuiElementProperties(button, **kwargs)
@staticmethod
def createDirectoryButton(**kwargs):
button = ctk.ctkDirectoryButton()
for key, value in iter(kwargs.items()):
if hasattr(button, key):
setattr(button, key, value)
return button
@staticmethod
def extendQtGuiElementProperties(element, **kwargs):
for key, value in iter(kwargs.items()):
if hasattr(element, key):
setattr(element, key, value)
else:
if key == "fixedHeight":
element.minimumHeight = value
element.maximumHeight = value
elif key == 'hidden':
if value:
element.hide()
else:
element.show()
else:
logging.error("%s does not have attribute %s" % (element.className(), key))
return element
@staticmethod
def createComboBox(**kwargs):
combobox = slicer.qMRMLNodeComboBox()
combobox.addEnabled = False
combobox.removeEnabled = False
combobox.noneEnabled = True
combobox.showHidden = False
for key, value in iter(kwargs.items()):
if hasattr(combobox, key):
setattr(combobox, key, value)
else:
logging.error("qMRMLNodeComboBox does not have attribute %s" % key)
combobox.setMRMLScene(slicer.mrmlScene)
return combobox
@staticmethod
def createProgressDialog(parent=None, value=0, maximum=100, labelText="", windowTitle="Processing...",
windowFlags=None, **kwargs):
"""Display a modal QProgressDialog. Go to QProgressDialog documentation
http://pyqt.sourceforge.net/Docs/PyQt4/qprogressdialog.html for more keyword arguments, that could be used.
E.g. progressbar = createProgressIndicator(autoClose=False) if you don't want the progress dialog to automatically
close.
Updating progress value with progressbar.value = 50
Updating label text with progressbar.labelText = "processing XYZ"
"""
progressIndicator = qt.QProgressDialog(parent if parent else slicer.util.mainWindow(),
windowFlags if windowFlags else qt.Qt.WindowStaysOnTopHint)
progressIndicator.minimumDuration = 0
progressIndicator.maximum = maximum
progressIndicator.value = value
progressIndicator.windowTitle = windowTitle
progressIndicator.labelText = labelText
for key, value in iter(kwargs.items()):
if hasattr(progressIndicator, key):
setattr(progressIndicator, key, value)
return progressIndicator
@staticmethod
def createHLayout(elements, **kwargs):
return UICreationHelpers.createLayout(qt.QHBoxLayout, elements, **kwargs)
@staticmethod
def createVLayout(elements, **kwargs):
return UICreationHelpers.createLayout(qt.QVBoxLayout, elements, **kwargs)
@staticmethod
def createLayout(layoutClass, elements, **kwargs):
widget = qt.QWidget()
rowLayout = layoutClass()
widget.setLayout(rowLayout)
for element in elements:
rowLayout.addWidget(element)
for key, value in iter(kwargs.items()):
if hasattr(rowLayout, key):
setattr(rowLayout, key, value)
return widget
@staticmethod
def createListView(name, headerLabels):
view = qt.QListView()
view.setObjectName(name)
view.setSpacing(3)
model = qt.QStandardItemModel()
model.setHorizontalHeaderLabels(headerLabels)
view.setModel(model)
view.setEditTriggers(qt.QAbstractItemView.NoEditTriggers)
return view, model
class ModuleWidgetMixin(GeneralModuleMixin, UICreationHelpers):
@property
def layoutManager(self):
return slicer.app.layoutManager()
def createSliceWidgetClassMembers(self, name):
widget = self.layoutManager.sliceWidget(name)
if not widget:
raise ValueError("sliceWidget name %s does not exist." % name)
self._addWidget(widget, name)
self._addCompositeNode(widget.mrmlSliceCompositeNode(), name)
self._addSliceView(widget.sliceView(), name)
self._addSliceViewInteractor(widget.sliceView().interactorStyle().GetInteractor(), name)
self._addSliceLogic(widget.sliceLogic(), name)
self._addSliceNode(widget.sliceLogic().GetSliceNode(), name)
def _addWidget(self, widget, name):
setattr(self, name.lower()+"Widget", widget)
self._widgets = getattr(self, "_widgets", [])
if not widget in self._widgets:
self._widgets.append(widget)
def _addCompositeNode(self, compositeNode, name):
setattr(self, name.lower()+"CompositeNode", compositeNode)
self._compositeNodes = getattr(self, "_compositeNodes", [])
if not compositeNode in self._compositeNodes:
self._compositeNodes.append(compositeNode)
def _addSliceView(self, sliceView, name):
setattr(self, name.lower()+"SliceView", sliceView)
self._sliceViews = getattr(self, "_sliceViews", [])
if not sliceView in self._sliceViews:
self._sliceViews.append(sliceView)
def _addSliceViewInteractor(self, sliceViewInteractor, name):
setattr(self, name.lower()+"SliceViewInteractor", sliceViewInteractor)
self._sliceViewInteractors = getattr(self, "_sliceViewInteractors", [])
if not sliceViewInteractor in self._sliceViewInteractors:
self._sliceViewInteractors.append(sliceViewInteractor)
def _addSliceLogic(self, sliceLogic, name):
setattr(self, name.lower()+"SliceLogic", sliceLogic)
self._sliceLogics = getattr(self, "_sliceLogics", [])
if not sliceLogic in self._sliceLogics:
self._sliceLogics.append(sliceLogic)
def _addSliceNode(self, sliceNode, name):
setattr(self, name.lower()+"SliceNode", sliceNode)
self._sliceNodes = getattr(self, "_sliceNodes", [])
if not sliceNode in self._sliceNodes:
self._sliceNodes.append(sliceNode)
@staticmethod
def getAllVisibleWidgets():
lm = slicer.app.layoutManager()
sliceLogics = lm.mrmlSliceLogics()
for n in range(sliceLogics.GetNumberOfItems()):
sliceLogic = sliceLogics.GetItemAsObject(n)
widget = lm.sliceWidget(sliceLogic.GetSliceNode().GetName())
if widget.sliceView().visible:
yield widget
@staticmethod
def linkAllSliceWidgets(link):
for widget in ModuleWidgetMixin.getAllVisibleWidgets():
compositeNode = widget.mrmlSliceCompositeNode()
compositeNode.SetLinkedControl(link)
compositeNode.SetInteractionFlagsModifier(4+8+16)
@staticmethod
def hideAllLabels():
for widget in ModuleWidgetMixin.getAllVisibleWidgets():
compositeNode = widget.mrmlSliceCompositeNode()
compositeNode.SetLabelOpacity(0)
@staticmethod
def setFiducialNodeVisibility(targetNode, show=True):
markupsLogic = slicer.modules.markups.logic()
markupsLogic.SetAllMarkupsVisibility(targetNode, show)
@staticmethod
def hideAllFiducialNodes():
for targetNode in slicer.util.getNodesByClass("vtkMRMLMarkupsFiducialNode"):
ModuleWidgetMixin.setFiducialNodeVisibility(targetNode, show=False)
@staticmethod
def setFOV(sliceLogic, FOV):
sliceNode = sliceLogic.GetSliceNode()
sliceNode.SetFieldOfView(FOV[0], FOV[1], FOV[2])
sliceNode.UpdateMatrices()
@staticmethod
def removeNodeFromMRMLScene(node):
if node:
slicer.mrmlScene.RemoveNode(node)
node = None
@staticmethod
def xyToRAS(sliceLogic, xyPoint):
sliceNode = sliceLogic.GetSliceNode()
rast = sliceNode.GetXYToRAS().MultiplyPoint(xyPoint + (0,1,))
return rast[:3]
@staticmethod
def refreshViewNodeIDs(node, sliceNodes):
displayNode = node.GetDisplayNode()
if displayNode:
displayNode.RemoveAllViewNodeIDs()
for sliceNode in sliceNodes:
displayNode.AddViewNodeID(sliceNode.GetID())
@staticmethod
def removeViewNodeIDs(node, sliceNodes):
displayNode = node.GetDisplayNode()
if displayNode:
displayNode.RemoveAllViewNodeIDs()
for sliceNode in sliceNodes:
displayNode.RemoveViewNodeID(sliceNode.GetID())
@staticmethod
def jumpSliceNodeToTarget(sliceNode, targetNode, index):
point = [0,0,0,0]
targetNode.GetMarkupPointWorld(index, 0, point)
sliceNode.JumpSlice(point[0], point[1], point[2])
@staticmethod
def resetToRegularViewMode():
interactionNode = slicer.mrmlScene.GetNodeByID("vtkMRMLInteractionNodeSingleton")
interactionNode.SwitchToViewTransformMode()
interactionNode.SetPlaceModePersistence(0)
@staticmethod
def confirmOrSaveDialog(message, title='mpReview'):
box = qt.QMessageBox(qt.QMessageBox.Question, title, message)
box.addButton("Exit, discard changes", qt.QMessageBox.AcceptRole)
box.addButton("Save changes", qt.QMessageBox.ActionRole)
box.addButton("Cancel", qt.QMessageBox.RejectRole)
return box.exec_()
def updateProgressBar(self, **kwargs):
progress = kwargs.pop('progress', None)
assert progress, "Keyword argument progress (instance of QProgressDialog) is missing"
for key, value in iter(kwargs.items()):
if hasattr(progress, key):
setattr(progress, key, value)
else:
print("key %s not found" % key)
slicer.app.processEvents()
@staticmethod
def setBackgroundToVolumeID(volume, clearLabels=True, showLabelOutline=False, sliceWidgets=None):
if not sliceWidgets:
sliceWidgets = ModuleWidgetMixin.getAllVisibleWidgets()
for widget in sliceWidgets:
compositeNode = widget.mrmlSliceCompositeNode()
if clearLabels:
compositeNode.SetLabelVolumeID(None)
compositeNode.SetForegroundVolumeID(None)
compositeNode.SetBackgroundVolumeID(volume.GetID() if volume else None)
sliceNode = widget.sliceLogic().GetSliceNode()
sliceNode.RotateToVolumePlane(volume)
sliceNode.SetUseLabelOutline(showLabelOutline)
def createIcon(self, filename, iconPath=None):
if not iconPath:
iconPath = os.path.join(self.modulePath, 'Resources/Icons')
path = os.path.join(iconPath, filename)
pixmap = qt.QPixmap(path)
return qt.QIcon(pixmap)
@staticmethod
def createAndGetRawColoredPixelMap(color, width=24, height=24, drawBorder=True):
pixmap = qt.QPixmap(width, height)
pixmap.fill(qt.QColor(color))
if drawBorder:
ModuleWidgetMixin.drawBorder(pixmap)
return ModuleWidgetMixin.pixelmapAsRaw(pixmap)
@staticmethod
def drawBorder(pixmap):
painter = qt.QPainter(pixmap)
rect = pixmap.rect()
tl = rect.topLeft()
tr = rect.topRight()
bl = rect.bottomLeft()
br = rect.bottomRight()
for start, end in [[tl, tr],[tr, br],[br, bl],[bl, tl]]:
painter.drawLine(start, end)
@staticmethod
def pixelmapAsRaw(pixmap):
byteArray = qt.QByteArray()
buffer = qt.QBuffer(byteArray)
pixmap.save(buffer, "PNG")
return "data:image/png;base64," + byteArray.toBase64().data().decode("utf-8")
def showMainAppToolbars(self, show=True):
w = slicer.util.mainWindow()
for c in w.children():
if str(type(c)).find('ToolBar')>0:
if show:
c.show()
else:
c.hide()
def _getMinimumTextWidth(self, text):
fm = qt.QFontMetrics(qt.QFont(text, 0))
width = fm.width(text)
return width
def hideAllSegmentations(self):
for segmentation in slicer.util.getNodesByClass('vtkMRMLSegmentationNode'):
segmentation.SetDisplayVisibility(False)
@staticmethod
def isQtVersionOlder(than="5.0.0"):
# packaging.version is not installed by default, so we cannot use it here
from distutils.version import StrictVersion
return StrictVersion(qt.Qt.qVersion()) < StrictVersion(than)
class ModuleLogicMixin(GeneralModuleMixin):
@property
def scalarVolumePlugin(self):
return slicer.modules.dicomPlugins['DICOMScalarVolumePlugin']()
@property
def volumesLogic(self):
return slicer.modules.volumes.logic()
@property
def markupsLogic(self):
return slicer.modules.markups.logic()
@property
def cropVolumeLogic(self):
return slicer.modules.cropvolume.logic()
@staticmethod
def truncatePath(path):
try:
split = path.split('/')
path = '.../' + split[-2] + '/' + split[-1]
except (IndexError, AttributeError):
pass
return path
@staticmethod
def cloneFiducials(original, cloneName, keepDisplayNode=False):
clone = slicer.vtkMRMLMarkupsFiducialNode()
clone.Copy(original)
clone.SetName(cloneName)
slicer.mrmlScene.AddNode(clone)
if not keepDisplayNode:
displayNode = slicer.vtkMRMLMarkupsDisplayNode()
slicer.mrmlScene.AddNode(displayNode)
clone.SetAndObserveDisplayNodeID(displayNode.GetID())
return clone
@staticmethod
def getMostRecentFile(path, fileType, filter=None):
assert type(fileType) is str
files = [f for f in os.listdir(path) if f.endswith(fileType)]
if len(files) == 0:
return None
mostRecent = None
storedTimeStamp = 0
for filename in files:
if filter and not filter in filename:
continue
actualFileName = filename.split(".")[0]
timeStamp = int(actualFileName.split("-")[-1])
if timeStamp > storedTimeStamp:
mostRecent = filename
storedTimeStamp = timeStamp
return mostRecent
@staticmethod
def getTargetPosition(targetNode, index):
position = [0.0, 0.0, 0.0]
targetNode.GetNthFiducialPosition(index, position)
return position
@staticmethod
def get3DDistance(p1, p2):
return [abs(p1[0]-p2[0]), abs(p1[1]-p2[1]), abs(p1[2]-p2[2])]
@staticmethod
def get3DEuclideanDistance(pos1, pos2):
import numpy as np
return np.linalg.norm(np.array(pos1)-np.array(pos2))
@staticmethod
def dilateMask(label, dilateValue=1.0, erodeValue=0.0, marginSize=5.0):
imagedata = label.GetImageData()
dilateErode = vtk.vtkImageDilateErode3D()
dilateErode.SetInputData(imagedata)
dilateErode.SetDilateValue(dilateValue)
dilateErode.SetErodeValue(erodeValue)
spacing = label.GetSpacing()
kernelSizePixel = [int(round((abs(marginSize) / spacing[componentIndex]+1)/2)*2-1) for componentIndex in range(3)]
dilateErode.SetKernelSize(kernelSizePixel[0], kernelSizePixel[1], kernelSizePixel[2])
dilateErode.Update()
label.SetAndObserveImageData(dilateErode.GetOutput())
@staticmethod
def getCentroidForLabel(labelNode, value):
if not labelNode:
return None
labelAddress = sitkUtils.GetSlicerITKReadWriteAddress(labelNode.GetName())
labelImage = sitk.ReadImage(labelAddress)
ls = sitk.LabelStatisticsImageFilter()
ls.Execute(labelImage, labelImage)
bb = ls.GetBoundingBox(value)
centroid = None # sagittal, coronal, axial
if len(bb) > 0:
centerIJK = [((bb[0] + bb[1]) / 2), ((bb[2] + bb[3]) / 2), ((bb[4] + bb[5]) / 2)]
logging.debug('BB is: ' + str(bb))
logging.debug('i_center = '+str(centerIJK[0]))
logging.debug('j_center = '+str(centerIJK[1]))
logging.debug('k_center = '+str(centerIJK[2]))
IJKtoRAS = vtk.vtkMatrix4x4()
labelNode.GetIJKToRASMatrix(IJKtoRAS)
IJKtoRASDir = vtk.vtkMatrix4x4()
labelNode.GetIJKToRASDirectionMatrix(IJKtoRASDir)
RAScoord = IJKtoRAS.MultiplyPoint((centerIJK[0], centerIJK[1], centerIJK[2], 1))
order = labelNode.ComputeScanOrderFromIJKToRAS(IJKtoRAS)
if order == 'IS':
RASDir = IJKtoRASDir.MultiplyPoint((RAScoord[0], RAScoord[1], RAScoord[2], 1))
centroid = [-RASDir[0], -RASDir[1], RASDir[2]]
elif order == 'AP':
RASDir = IJKtoRASDir.MultiplyPoint((RAScoord[0], RAScoord[1], RAScoord[2], 1))
centroid = [-RASDir[0], -RASDir[2], -RASDir[1]]
elif order == 'LR':
RASDir = IJKtoRASDir.MultiplyPoint((RAScoord[2], RAScoord[1], RAScoord[0], 1))
centroid = [RASDir[0], -RASDir[2], -RASDir[1]]
return centroid
@staticmethod
def roundInt(value, exceptionReturnValue=0):
try:
return int(round(value))
except ValueError:
return exceptionReturnValue
@staticmethod
def getIJKForXYZ(sliceWidget, p):
xyz = sliceWidget.sliceView().convertRASToXYZ(p)
layerLogic = sliceWidget.sliceLogic().GetBackgroundLayer()
xyToIJK = layerLogic.GetXYToIJKTransform()
ijkFloat = xyToIJK.TransformDoublePoint(xyz)
ijk = [ModuleLogicMixin.roundInt(value) for value in ijkFloat]
return ijk
@staticmethod
def createCroppedVolume(inputVolume, roi):
cropVolumeLogic = slicer.modules.cropvolume.logic()
cropVolumeParameterNode = slicer.vtkMRMLCropVolumeParametersNode()
cropVolumeParameterNode.SetROINodeID(roi.GetID())
cropVolumeParameterNode.SetInputVolumeNodeID(inputVolume.GetID())
cropVolumeParameterNode.SetVoxelBased(True)
cropVolumeLogic.Apply(cropVolumeParameterNode)
croppedVolume = slicer.mrmlScene.GetNodeByID(cropVolumeParameterNode.GetOutputVolumeNodeID())
return croppedVolume
@staticmethod
def createMaskedVolume(inputVolume, labelVolume, outputVolumeName=None):
maskedVolume = slicer.vtkMRMLScalarVolumeNode()
if outputVolumeName:
maskedVolume.SetName(outputVolumeName)
slicer.mrmlScene.AddNode(maskedVolume)
params = {'InputVolume': inputVolume, 'MaskVolume': labelVolume, 'OutputVolume': maskedVolume}
slicer.cli.run(slicer.modules.maskscalarvolume, None, params, wait_for_completion=True)
return maskedVolume
@staticmethod
def createVTKTubeFilter(startPoint, endPoint, radius, numSides):
lineSource = vtk.vtkLineSource()
lineSource.SetPoint1(startPoint)
lineSource.SetPoint2(endPoint)
tubeFilter = vtk.vtkTubeFilter()
tubeFilter.SetInputConnection(lineSource.GetOutputPort())
tubeFilter.SetRadius(radius)
tubeFilter.SetNumberOfSides(numSides)
tubeFilter.CappingOn()
tubeFilter.Update()
return tubeFilter
@staticmethod
def createLabelMapFromCroppedVolume(volume, name, lowerThreshold=0, upperThreshold=2000, labelValue=1):
volumesLogic = slicer.modules.volumes.logic()
labelVolume = volumesLogic.CreateAndAddLabelVolume(volume, name)
imageData = labelVolume.GetImageData()
imageThreshold = vtk.vtkImageThreshold()
imageThreshold.SetInputData(imageData)
imageThreshold.ThresholdBetween(lowerThreshold, upperThreshold)
imageThreshold.SetInValue(labelValue)
imageThreshold.Update()
labelVolume.SetAndObserveImageData(imageThreshold.GetOutput())
return labelVolume
@staticmethod
def getIslandCount(image, index):
imageSize = image.GetSize()
index = [0, 0, index]
extractor = sitk.ExtractImageFilter()
extractor.SetSize([imageSize[0], imageSize[1], 0])
extractor.SetIndex(index)
slice = extractor.Execute(image)
cc = sitk.ConnectedComponentImageFilter()
cc.Execute(slice)
return cc.GetObjectCount()
@staticmethod
def applyOtsuFilter(volume):
outputVolume = slicer.vtkMRMLScalarVolumeNode()
outputVolume.SetName('ZFrame_Otsu_Output')
slicer.mrmlScene.AddNode(outputVolume)
params = {'inputVolume': volume.GetID(),
'outputVolume': outputVolume.GetID(),
'insideValue': 0, 'outsideValue': 1}
slicer.cli.run(slicer.modules.otsuthresholdimagefilter, None, params, wait_for_completion=True)
return outputVolume
@staticmethod
def getDirectorySize(directory):
size = 0
for path, dirs, files in os.walk(directory):
for currentFile in files:
if not ".DS_Store" in currentFile:
size += os.path.getsize(os.path.join(path, currentFile))
return size
@staticmethod
def createDirectory(directory, message=None):
if message:
logging.debug(message)
try:
os.makedirs(directory)
except OSError:
logging.debug('Failed to create the following directory: ' + directory)
@staticmethod
def findElement(dom, name):
for e in [e for e in dom.getElementsByTagName('element') if e.getAttribute('name') == name]:
try:
return e.childNodes[0].nodeValue
except IndexError:
return ""
@staticmethod
def getDICOMValue(inputArg, tagName, default=""):
try:
if type(inputArg) is pydicom.dataset.FileDataset:
if hasattr(inputArg, tagName):
value = getattr(inputArg, tagName)
else:
value = default
elif type(inputArg) is str and os.path.isfile(inputArg):
value = slicer.dicomDatabase.fileValue(inputArg, tagName)
elif type(inputArg) is slicer.vtkMRMLScalarVolumeNode:
f = slicer.dicomDatabase.fileForInstance(inputArg.GetAttribute("DICOM.instanceUIDs").split(" ")[0])
value = slicer.dicomDatabase.fileValue(f, tagName)
elif type(inputArg) is slicer.vtkMRMLMultiVolumeNode:
f = slicer.dicomDatabase.fileForInstance(inputArg.GetAttribute("DICOM.instanceUIDs").split(" ")[0])
value = slicer.dicomDatabase.fileValue(f, tagName)
else:
logging.warning("Could not retrieve DICOM tag value from input parameter %s" % inputArg)
value = default
except Exception as exc:
import traceback
traceback.print_exc()
logging.error(exc)
value = default
return value
@staticmethod
def getFileList(directory):
return [f for f in os.listdir(directory) if ".DS_Store" not in f]
@staticmethod
def importStudy(dicomDataDir):
indexer = ctk.ctkDICOMIndexer()
indexer.addDirectory(slicer.dicomDatabase, dicomDataDir)
indexer.waitForImportFinished()
@staticmethod
def createScalarVolumeNode(name=None):
return ModuleLogicMixin.createNode(slicer.vtkMRMLScalarVolumeNode, name=name)
@staticmethod
def createBSplineTransformNode(name=None):
return ModuleLogicMixin.createNode(slicer.vtkMRMLBSplineTransformNode, name=name)
@staticmethod
def createLinearTransformNode(name=None):
return ModuleLogicMixin.createNode(slicer.vtkMRMLLinearTransformNode, name=name)
@staticmethod
def createModelNode(name=None):
return ModuleLogicMixin.createNode(slicer.vtkMRMLModelNode, name=name)
@staticmethod
def createNode(nodeType, name=None):
node = nodeType()
if name:
node.SetName(name)
slicer.mrmlScene.AddNode(node)
return node
@staticmethod
def saveNodeData(node, outputDir, extension, replaceUnwantedCharacters=True, name=None, overwrite=True):
name = name if name else node.GetName()
if replaceUnwantedCharacters:
name = ModuleLogicMixin.replaceUnwantedCharacters(name)
filename = os.path.join(outputDir, name + extension)
if os.path.exists(filename) and not overwrite:
return True, name
return slicer.util.saveNode(node, filename), name
@staticmethod
def replaceUnwantedCharacters(string, characters=None, replaceWith="-"):
if not characters:
characters = [": ", " ", ":", "/"]
for character in characters:
string = string.replace(character, replaceWith)
return string
@staticmethod
def handleSaveNodeDataReturn(success, name, successfulList, failedList):
listToAdd = successfulList if success else failedList
listToAdd.append(name)
@staticmethod
def applyTransform(transform, node):
tfmLogic = slicer.modules.transforms.logic()
node.SetAndObserveTransformNodeID(transform.GetID())
tfmLogic.hardenTransform(node)
@staticmethod
def createAndObserveDisplayNode(node, displayNodeClass=slicer.vtkMRMLDisplayNode):
displayNode = displayNodeClass()
slicer.mrmlScene.AddNode(displayNode)
node.SetAndObserveDisplayNodeID(displayNode.GetID())
return displayNode
@staticmethod
def setNodeVisibility(node, visible):
displayNode = node.GetDisplayNode()
if displayNode is not None:
displayNode.SetVisibility(visible)
@staticmethod
def setNodeSliceIntersectionVisibility(node, visible):
displayNode = node.GetDisplayNode()
if displayNode is not None:
displayNode.SetSliceIntersectionVisibility(visible)
@staticmethod
def isVolumeExtentValid(volume):
imageData = volume.GetImageData()
try:
extent = imageData.GetExtent()
return extent[1] > 0 and extent[3] > 0 and extent[5] > 0
except AttributeError:
return False
@staticmethod
def isAnyListItemInString(string, listItem):
return any(item in string for item in listItem)
@staticmethod
def getReferencedVolumeFromSegmentationNode(segmentationNode):
if not segmentationNode:
return None
return segmentationNode.GetNodeReference(segmentationNode.GetReferenceImageGeometryReferenceRole())
@staticmethod
def runBRAINSResample(inputVolume, referenceVolume, outputVolume, warpTransform=None):
params = {'inputVolume': inputVolume, 'referenceVolume': referenceVolume, 'outputVolume': outputVolume,
'interpolationMode': 'NearestNeighbor', 'pixelType':'short'}
if warpTransform:
params['warpTransform'] = warpTransform
logging.debug('About to run BRAINSResample CLI with those params: %s' % params)
slicer.cli.run(slicer.modules.brainsresample, None, params, wait_for_completion=True)
slicer.mrmlScene.AddNode(outputVolume)
| {"/SlicerDevelopmentToolboxUtils/buttons.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/widgets.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/helpers.py": ["/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/widgets.py": ["/SlicerDevelopmentToolboxUtils/constants.py", "/SlicerDevelopmentToolboxUtils/decorators.py", "/SlicerDevelopmentToolboxUtils/events.py", "/SlicerDevelopmentToolboxUtils/helpers.py", "/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/icons.py"], "/SlicerDevelopmentToolboxUtils/module/logic.py": ["/SlicerDevelopmentToolboxUtils/module/base.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py": ["/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py"], "/SlicerDevelopmentToolboxUtils/module/plugin.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/step.py": ["/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/module/session.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/module/base.py"], "/SlicerDevelopmentToolboxUtils/icons.py": ["/SlicerDevelopmentToolboxUtils/decorators.py"], "/SlicerDevelopmentToolboxUtils/forms/FormsDialog.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGeneratorFactory.py"], "/SlicerDevelopmentToolboxUtils/forms/JSONFormGenerator.py": ["/SlicerDevelopmentToolboxUtils/forms/FormGenerator.py", "/SlicerDevelopmentToolboxUtils/mixins.py"], "/SlicerDevelopmentToolboxUtils/module/base.py": ["/SlicerDevelopmentToolboxUtils/mixins.py", "/SlicerDevelopmentToolboxUtils/decorators.py"]} |
50,136 | arockiapriya/flask-rest-simple | refs/heads/master | /rest_api/__init__.py | from flask import Blueprint
api = Blueprint('dummy_name', __name__)
from .index import *
from .template_controller import *
from .math_controller import * | {"/rest_api/__init__.py": ["/rest_api/template_controller.py", "/rest_api/math_controller.py"], "/rest_api/math_controller.py": ["/rest_api/__init__.py"], "/rest_api/template_controller.py": ["/rest_api/__init__.py"]} |
50,137 | arockiapriya/flask-rest-simple | refs/heads/master | /rest_api/math_controller.py | from . import api
from flask import current_app as app
from flask import request
from .response_utils import JSON_MIME_TYPE, success_, success_json
'''
/math/add?a=2&b=2
http://127.0.0.1:5000/math/add?a=2&b=2
'''
@api.route('/math/add')
def add():
a = request.args.get('a', type=int)
b = request.args.get('b', type=int)
'''
a = request.form.get('a', type=int)
b = request.form.get('b', type=int)
'''
c = a + b
result_json = {
'result': c,
'api_error': 0
}
return success_json(result_json)
'''
/math/add/post?a=2&b=2
http://127.0.0.1:5000/math/add/post?a=2&b=2
'''
@api.route('/math/add/post', methods=['POST'])
def add_post():
'''
this can be used as well
a = request.args.get('a', type=int)
b = request.args.get('b', type=int)
'''
a = request.form.get('a', type=int)
b = request.form.get('b', type=int)
c = a + b
result_json = {
'result': c,
'api_error': 0
}
return success_json(result_json)
'''
/math/subtract?a=2&b=2
http://127.0.0.1:5000/math/subtract?a=2&b=44
'''
@api.route('/math/subtract')
def subtract():
a = request.args.get('a', type=int)
b = request.args.get('b', type=int)
c = a - b
result_json = {
'result': c,
'api_error': 0
}
return success_json(result_json)
'''
App Config:
https://stackoverflow.com/questions/18214612/how-to-access-app-config-in-a-blueprint
Decorators
https://medium.com/@nguyenkims/python-decorator-and-flask-3954dd186cda
''' | {"/rest_api/__init__.py": ["/rest_api/template_controller.py", "/rest_api/math_controller.py"], "/rest_api/math_controller.py": ["/rest_api/__init__.py"], "/rest_api/template_controller.py": ["/rest_api/__init__.py"]} |
50,138 | arockiapriya/flask-rest-simple | refs/heads/master | /rest_api/template_controller.py | from . import api
from flask import current_app as app
from flask import request
from .response_utils import JSON_MIME_TYPE, success_, success_json
'''
/template/add?a=2&b=2
http://127.0.0.1:5000/template/add?a=2&b=2
'''
@api.route('/template/add')
def add1():
a = request.args.get('a', type=int)
b = request.args.get('b', type=int)
'''
a = request.form.get('a', type=int)
b = request.form.get('b', type=int)
'''
c = a + b
result_json = {
'result': c,
'api_error': 0
}
return success_json(result_json)
'''
/template/add/post?a=2&b=2
http://127.0.0.1:5000/template/add/post?a=2&b=2
'''
@api.route('/template/add/post', methods=['POST'])
def add1_post():
'''
this can be used as well
a = request.args.get('a', type=int)
b = request.args.get('b', type=int)
'''
a = request.form.get('a', type=int)
b = request.form.get('b', type=int)
c = a + b
result_json = {
'result': c,
'api_error': 0
}
return success_json(result_json)
'''
/template/subtract?a=2&b=2
http://127.0.0.1:5000/template/subtract?a=2&b=44
'''
@api.route('/template/subtract')
def subtract1():
a = request.args.get('a', type=int)
b = request.args.get('b', type=int)
c = a - b
result_json = {
'result': c,
'city' : app.config['city'],
'api_error': 0
}
return success_json(result_json)
'''
App Config:
https://stackoverflow.com/questions/18214612/how-to-access-app-config-in-a-blueprint
''' | {"/rest_api/__init__.py": ["/rest_api/template_controller.py", "/rest_api/math_controller.py"], "/rest_api/math_controller.py": ["/rest_api/__init__.py"], "/rest_api/template_controller.py": ["/rest_api/__init__.py"]} |
50,147 | jokh0108/recobot | refs/heads/master | /bot.py | # -*- coding: utf-8 -*-
from FE import FE
from w2v_sim import W2V
from aurochs.misc import Aux
from pprint import PrettyPrinter
from slackclient import SlackClient
from google_translator import Translator
import time
import random
import json
class Bot():
def __init__(self):
self.pp = PrettyPrinter()
self.logger = Aux.get_logger("bot")
# self.logger.debug = lambda x: self.logger.debug(self.pp.pformat(x)/
self.bot_token = "xoxb-710178628226-723981424945-I8nqRBYzFyv9UoOTC9h9KOTY"
# searchdog id
self.bot_id = "BM9TLPGHJ"
self.w2v = W2V()
self.fe = FE()
self.sc = SlackClient(self.bot_token)
self.sc.rtm_connect()
self.tc = Translator()
self.threshold = 10.0
self.topn = 1
self.counter = 0
def run(self):
while True:
rtm_output = self.sc.rtm_read()
if rtm_output:
if len(rtm_output) > 0:
if not rtm_output[0].get('name') == 'emoji_use':
self.logger.debug(rtm_output)
rtm_output = rtm_output[0]
else:
time.sleep(0.2)
continue
message = rtm_output.get('text', str())
if rtm_output.get('bot_id', None) != self.bot_id and len(message) > 0:
# if message : 김치돈가스뚝배기카레맛
feats = self.fe.single_message_extract(rtm_output)
# feats == (id, [term1, term2, ...])
sim_emoji = []
if feats:
t = time.time()
for feat in feats[1]:
# [김치, 돈가스, 뚝배기, 카레]
top_emojis= self.w2v.get_sim_emoji(feat)
top_emoji = top_emojis[:self.topn]
# [(feat, emoji, similarity), (feat, emoji, sim), ...]
self.logger.debug(top_emoji)
sim_emoji.extend(top_emoji)
self.logger.debug("time passed : %.2fs" % (time.time() - t))
else:
# 김치돈가스뚝배기카레맛
top_emojis = self.w2v.get_sim_emoji(message)
top_emoji = top_emojis[:self.topn]
# [(feat, emoji, similarity), (feat, emoji, sim), ...]
self.logger.debug(top_emoji)
sim_emoji.extend(top_emoji)
if sim_emoji:
random.shuffle(sim_emoji)
for t in sim_emoji:
self.logger.debug("%s -> %s : %.3f"%(t[0], t[1], t[2]))
out_num = 3
for reaction_tuple in sim_emoji[:out_num+1]:
feat, emoji, sim = reaction_tuple
self.logger.debug("(feat -> emoji) : (%s -> %s), similariy : %.3f"%(feat, emoji, sim))
res = self.sc.api_call(
"reactions.add",
channel = rtm_output.get('channel'),
name = emoji,
timestamp = rtm_output.get("ts")
)
if not res.get('ok'):
self.logger.debug(res)
time.sleep(0.2)
if __name__ == "__main__":
bot = Bot()
bot.run()
| {"/bot.py": ["/FE.py", "/w2v_sim.py", "/google_translator.py"]} |
50,148 | jokh0108/recobot | refs/heads/master | /FE.py | # -*- coding: utf-8 -*-
import sys
import json
from pprint import pprint
from aurochs.misc import Aux
from aurochs.vectorspace import IndexTerms
class FE:
def __init__(self):
self.logger = Aux.get_logger('FE')
self.fe = IndexTerms('slack_messages')
self.messages = None
def load_model(self):
with open('reaction_history.json') as json_file:
self.messages = json.load(json_file)
for k, v in self.messages.iteritems():
print k, v
def run(self):
self.load_model()
i = 0
for m, r in self.messages.iteritems():
print m
messages_terms = self.fe.extract_index_term(i, m)
i += 1
if messages_terms[1]:
for feat in messages_terms[1]:
print feat
print '-'*50
def single_message_extract(self, message):
msg_id = message.get('client_msg_id')
m = message.get('text').lower()
if not m:
return False
message_terms = self.fe.extract_index_term(msg_id, m)
# (id, [term1, term2, term3, ...])
self.logger.debug(message_terms)
if message_terms[1] and len(message_terms[1]) > 0:
self.logger.debug("feat : %s" % (",".join(message_terms[1])))
return message_terms
else:
return False
if __name__ == '__main__':
fe = FE()
if sys.argv[1]:
message = {'client_msg_id': 1, 'text': sys.argv[1]}
fe.single_message_extract(message)
else:
fe.run()
| {"/bot.py": ["/FE.py", "/w2v_sim.py", "/google_translator.py"]} |
50,149 | jokh0108/recobot | refs/heads/master | /google_translator.py | # Imports the Google Cloud client library
from google.cloud import translate
from aurochs.misc import Aux
class Translator:
def __init__(self):
self.translate_client = translate.Client.from_service_account_json('/daum/oscar/recobot-test/google-cloud-auth.json')
self.logger = Aux.get_logger('Translator')
def translate(self, text= 'Hello World!', target= 'en'):
# Translates some text into Russian
translation = self.translate_client.translate(
text,
target_language=target)
self.logger.debug(u'Text: {}'.format(text))
self.logger.debug(u'Translation: {}'.format(translation['translatedText']))
return translation['translatedText']
if __name__ =='__main__':
t = Translator()
t.translate()
| {"/bot.py": ["/FE.py", "/w2v_sim.py", "/google_translator.py"]} |
50,150 | jokh0108/recobot | refs/heads/master | /naver_translator.py | # -*- coding: utf-8 -*-
import os
import sys
import requests
class Translator():
def __init__(self):
self.client_id = "v6feWh_dn3A26cL4wB4K"
self.client_secret = "FW4suGrz8J"
encText = "나는 오늘 삼겹살과 피자를 맛있게 먹었다"
payload = {"source" : 'ko', "target":"en", "text": encText}
headers = {"X-Naver-Client-Id" : self.client_id, "X-Naver-Client-Secret": self.client_secret}
url = "https://openapi.naver.com/v1/language/translate"
res = requests.get(url, params=payload)
print res
if __name__ == '__main__':
t = Translator()
| {"/bot.py": ["/FE.py", "/w2v_sim.py", "/google_translator.py"]} |
50,151 | jokh0108/recobot | refs/heads/master | /w2v_sim.py | # -*- coding: utf-8 -*-
import time
import sys
import os
from aurochs.buffalo import feature
from aurochs.misc import Aux
import json
import requests
class W2V():
def __init__(self):
self.logger = Aux.get_logger('w2v')
self.key = None
self.num = 100000
self.d = '512d'
self.topic = 'unified-buffalo-' + self.d
self.name = 'w2v_' + self.d
self.save_path = './' + self.name + '/'
self.emojis = None
self.custom_emojis = None
self.sims_with_keyword = None
if not os.path.isdir(self.save_path):
os.mkdir(self.save_path)
self.ft = None
self.topn = 3
self.threshold = 10.0
self.load_model()
def load_model(self):
# get emoji list
if not self.emojis:
self.emojis = requests.get('https://raw.githubusercontent.com/iamcal/emoji-data/master/emoji.json').json()
# get custom emoji list (used in kakao-recoteam slack)
if not self.custom_emojis:
self.custom_emojis = requests.get('https://slack.com/api/emoji.list?token=xoxb-9983699043-717460665509-LvJsTUCLSHeHeZGIAnC5K79E').json()
self.emojis = {each['short_name']: each['short_name'] for each in self.emojis}
self.custom_emojis = self.custom_emojis['emoji']
self.custom_emojis = {k: k for k in self.custom_emojis.keys()}
# emoji + custom_emoji
self.emojis.update(self.custom_emojis)
# download word2vec model
if not os.path.isfile(self.save_path + 'main'):
os.system('ModelHouse export word2vec ' + self.topic + ' ' + self.save_path)
# load w2v model
self.ft = feature.load(self.save_path + 'main')
def load_json(self, recs):
fname = self.save_path + self.key + '.json'
if os.path.isfile(fname):
if os.path.getsize(fname) > 10:
with open(self.save_path + self.key + '.json', 'r') as f:
self.sims_with_keyword = json.load(f)
if not self.sims_with_keyword:
return False
else:
os.remove(fname)
self.logger.debug(self.key)
# self.key shouldn't be unicode
self.sims_with_keyword = self.ft.most_similar(self.key, self.num)
if len(self.sims_with_keyword) > 0:
self.logger.debug(self.sims_with_keyword[0])
else:
self.logger.debug(self.sims_with_keyword)
self.sims_with_keyword = {kv[0].decode('utf-8'): kv[1] for kv in self.sims_with_keyword}
with open(self.save_path + self.key + '.json', 'w') as f:
json.dump(self.sims_with_keyword, f)
return True
def get_sim_emoji(self, keyword):
self.logger.debug(type(keyword))
# if alreay exists
if isinstance(keyword, unicode):
# unicode -> utf-8
keyword = keyword.encode('utf-8')
self.logger.debug(type(keyword))
self.key = keyword
recs = []
j = self.load_json(recs)
if not j:
return ''
if recs:
return recs
self.key = self.key.decode('utf-8')
recs = []
if self.emojis.get(self.key):
recs.append((self.key, self.emojis.get(self.key), max(self.sims_with_keyword.values() if self.sims_with_keyword.values() else [0]) + 1.0))
for emoji in self.emojis.keys():
sim = self.sims_with_keyword.get(emoji)
if sim and sim > self.threshold:
recs.append((self.key, emoji, sim))
self.logger.debug(recs[:2])
if recs:
recs = sorted(recs, key=lambda x: x[2], reverse=True)
for i in recs[:self.topn]:
self.logger.debug('[in recs] keyword : %s, emoji : %s, similarity : %.3f' % (i[0], i[1], i[2]))
self.sims_with_keyword = sorted([(k, v) for k, v in self.sims_with_keyword.iteritems()], key=lambda x: x[1], reverse=True)
for k, v in self.sims_with_keyword[:self.topn]:
self.logger.debug('[in self.sims_with_keyword] word : %s, similarity : %.3f' % (k, v))
# print item[0]
if len(recs) > 0:
# [(k, e, s), (k, e, s), ...]
return recs[:self.topn]
else:
# []
return recs
if __name__ == '__main__':
w2v = W2V()
print(sys.argv[1])
res = w2v.get_sim_emoji(sys.argv[1])
| {"/bot.py": ["/FE.py", "/w2v_sim.py", "/google_translator.py"]} |
50,152 | wgxli/chinese-text-analyzer | refs/heads/master | /daemon.py | #! /bin/python3
# daemon.py - Local HTTP daemon for Chinese text segmentation.
# Note that there is no error validation.
# I wouldn't run this on a public-facing webserver.
from http.server import HTTPServer, BaseHTTPRequestHandler
from urllib.parse import urlparse, unquote
import json
from hanziconv import HanziConv
from g2pc import G2pC
from config import host, port, address
# Use G2pC for Chinese segmentation
segmenter = G2pC()
def process_segment(segment):
char, pos, pinyin, _, meaning, _ = segment
return {
'character': char,
'pos': pos,
'pinyin': pinyin.split(),
'meaning': meaning[1:-1].split('/'),
}
class RequestHandler(BaseHTTPRequestHandler):
def do_GET(self):
# Get the query text.
try:
query = unquote(urlparse(self.path).geturl())[1:]
print('[query]', query)
except:
print('[error] Malformed Query')
simplified = HanziConv.toSimplified(query)
segments = [
process_segment(segment)
for segment in segmenter(simplified)
]
response = json.dumps(segments)
self.send_response(200)
self.end_headers()
self.wfile.write(response.encode())
daemon = HTTPServer(address, RequestHandler)
print(f'Web server initialized at {host}:{port}')
daemon.serve_forever()
| {"/daemon.py": ["/config.py"], "/client.py": ["/config.py"]} |
50,153 | wgxli/chinese-text-analyzer | refs/heads/master | /client.py | #! /bin/python3
# client.py - Analyzes the given Chinese text and displays results graphically.
# Usage: python3 client.py 中文文体
import json
import sys
import subprocess
from pathlib import Path
import requests
from config import host, port, anki_integration, anki_save_location, show_confirmation
# You may need to adjust the settings below
# to get a good window size for your GTK setup
base_height = 120 # Height of the popup window without any entries
row_height = 30 # Height of each entry row
# Character limit for "meaning" column
meaning_limit = 60
anki_file = anki_save_location / 'anki.csv'
# Get list of words already added to csv
if anki_file.exists():
with open(anki_file, 'r') as f:
added = {line.split(',')[0] for line in f.readlines()}
else:
added = set()
def display_error(title, text):
"""Displays the given error message in a GTK window. Requires `zenity`."""
subprocess.run([
'zenity', '--error',
'--width', '300',
'--title', title,
'--text', text
])
def query(text):
"""Queries the daemon for a text analysis."""
try:
response = requests.get(f'http://{host}:{port}/{text}').text
except requests.exceptions.ConnectionError:
display_error('Daemon not Reachable', 'Please ensure that daemon.py is running.')
sys.exit()
segmentation = json.loads(response)
return segmentation
def add_tone(vowel, tone):
"""
Adds the given (numerical) tone to a vowel.
>>> add_tone('a', 3)
'ǎ'
"""
return {
'a': 'āáǎàa',
'e': 'ēéěèe',
'i': 'īíǐìi',
'o': 'ōóǒòo',
'u': 'ūúǔùu',
'ü': 'ǖǘǚǜü'
}[vowel][tone-1]
def parse_pinyin(syllable):
"""
Converts numerical pinyin to accented pinyin.
>>> parse_pinyin('yan2')
'yán'
>>> parse_pinyin('xiang3')
'xiǎng'
"""
syllable, tone = list(syllable[:-1].replace('u:', 'ü')), int(syllable[-1])
vowels = {c: i for (i, c) in enumerate(syllable) if (c in 'aeiouü')}
def place_accent(letter):
syllable[vowels[letter]] = add_tone(letter, tone)
# Following algorithm on Wikipedia
if len(vowels) == 1:
place_accent(list(vowels.keys())[0])
elif 'a' in vowels:
place_accent('a')
elif 'e' in vowels:
place_accent('e')
elif 'ou' in ''.join(syllable):
place_accent('o')
else:
second_vowel = syllable[list(sorted(vowels.values()))[1]]
place_accent(second_vowel)
return ''.join(syllable)
def limit_length(definitions, limit=meaning_limit):
"""
Returns an initial sublist (prefix) of `definitions` as long as possible
without exceeding `limit` characters total.
"""
output = []
length = 0
for entry in definitions:
length += len(entry)
if length > limit: break
output.append(entry)
return output
def display_results(results):
"""
Displays the given parse results in a graphical window.
Assumes that `zenity` is installed.
"""
data = []
# Process raw segmentation results from the daemon
for entry in results:
try:
data.append((
entry['character'],
' '.join(map(parse_pinyin, entry['pinyin'])),
' · '.join(limit_length(entry['meaning']))
))
except ValueError:
# Ignore any input that isn't a Chinese character
print('Error processing', entry['character'])
pass
if not data:
display_error('No Input', 'No Chinese text was detected.')
sys.exit()
# Flatten data for zenity
window_data = []
for entry in data:
if anki_integration: window_data.append('')
window_data.extend(entry)
# Open zenity window and get selections (if Anki integration active)
window_output = subprocess.run([
'zenity',
'--list',
'--title', 'Chinese Analysis',
'--width', '700',
'--height', str(base_height + row_height * len(data)),
*([
'--checklist',
'--text', 'Select any words to add them to Anki.',
'--column', 'Anki'
] if anki_integration else
[
'--text', 'Breakdown of the selected text:',
]),
'--column', 'Word',
'--column', 'Pinyin',
'--column', 'Meaning',
*window_data
], capture_output=True).stdout.decode()
# Add selected words to Anki csv
selected_words = set([x for x in window_output.strip().split('|') if x])
added_words = selected_words - added
existing_words = selected_words & added
if anki_integration and selected_words:
with open(anki_file, 'a') as f:
for word in added_words:
entry = next(x for x in data if x[0] == word)
print(*entry, sep='\t', file=f)
if show_confirmation:
subprocess.run([
'zenity', '--info',
'--width', '200',
'--title', 'Words added',
'--text', ''.join([
'Added to Anki: ',
', '.join(added_words) or 'None',
'\n',
'Already Added: ',
', '.join(existing_words) or 'None'
])
])
# We want exactly one argument, the Chinese text to analyze
if len(sys.argv) != 2:
raise ValueError('Exactly one command-line argument should be provided!')
results = query(sys.argv[1])
display_results(results)
| {"/daemon.py": ["/config.py"], "/client.py": ["/config.py"]} |
50,154 | wgxli/chinese-text-analyzer | refs/heads/master | /config.py | from pathlib import Path
# Address of the daemon
host, port = address = ('localhost', 1337)
# Whether to enable Anki integration
anki_integration = True
anki_save_location = Path('~').expanduser()
# Whether to show confirmation after adding words to Anki
show_confirmation = False
| {"/daemon.py": ["/config.py"], "/client.py": ["/config.py"]} |
50,155 | khodor14/pyvg | refs/heads/master | /pyvg/sequences.py | from .vgobjects import ProtoGraph
import json
import logging
class SequenceRetriever(object):
_compliments = {"A": "T",
"C": "G",
"T": "A",
"G": "C"}
def __init__(self, node_dict):
self.nodes = node_dict
def _reverse_compliment(self, sequenence):
return "".join(self._compliments[c] for c in sequenence[::-1])
@classmethod
def from_vg_graph(cls, vg_graph_file_name):
vg_graph = ProtoGraph.from_vg_graph_file(
vg_graph_file_name, True, True)
return cls(vg_graph.nodes)
@classmethod
def from_vg_json_graph(cls, vg_graph_file_name):
node_dict = {}
f = open(vg_graph_file_name)
i = 1
for line in f.readlines():
line = json.loads(line)
if "node" in line:
node_objects = line["node"]
for node_object in node_objects:
node_dict[node_object["id"]] = node_object["sequence"].lower()
i += 1
if i % 1000000 == 0:
logging.info("%d nodes processed" % i)
return cls(node_dict)
def get_sequence_on_directed_node(self, node_id, start=0, end=False):
"""Handles directed nodes"""
if node_id > 0:
return self.get_sequence(node_id, start, end)
else:
node_size = len(self.get_sequence(-node_id))
if not end:
end = node_size
new_start = node_size - end
new_end = node_size - start
reverse_sequence = self.get_sequence(-node_id, new_start, new_end)
return self._reverse_compliment(reverse_sequence)
def get_sequence(self, node_id, start=0, end=False):
assert node_id > 0
nodes = self.nodes
if start == 0 and not end:
return nodes[node_id]
elif not end:
return nodes[node_id][start:]
else:
return nodes[node_id][start:end]
def get_interval_sequence(self, interval):
rps = interval.region_paths
start_node = rps[0]
end_node = rps[-1]
if start_node == end_node and len(rps) == 1:
return self.get_sequence_on_directed_node(
start_node,
interval.start_position.offset,
interval.end_position.offset)
else:
start_sequence = self.get_sequence_on_directed_node(
start_node,
interval.start_position.offset)
end_sequence = self.get_sequence_on_directed_node(
end_node,
0,
interval.end_position.offset)
middle_sequence = ""
for rp in rps[1:-1]:
middle_sequence += self.get_sequence_on_directed_node(rp)
return "%s%s%s" % (start_sequence, middle_sequence, end_sequence)
| {"/pyvg/sequences.py": ["/pyvg/vgobjects.py"], "/tests/test_datastructures.py": ["/pyvg.py"], "/pyvg/alignmentcollection.py": ["/pyvg/conversion.py"], "/pyvg.py": ["/pyvg/alignmentcollection.py"], "/pyvg/__init__.py": ["/pyvg/vgobjects.py", "/pyvg/sequences.py", "/pyvg/util.py"], "/tests/test_conversion.py": ["/pyvg/conversion.py"], "/pyvg/construct.py": ["/pyvg/util.py"], "/pyvg/alignment.py": ["/pyvg/util.py"], "/tests/test_sequences.py": ["/pyvg/sequences.py"], "/pyvg/vgobjects.py": ["/pyvg.py"], "/pyvg/view.py": ["/pyvg/util.py"], "/pyvg/conversion.py": ["/pyvg/vgobjects.py"]} |
50,156 | khodor14/pyvg | refs/heads/master | /tests/test_datastructures.py | from pyvg import Graph, Mapping, Alignment, Node, Edge, Snarls, Path, ProtoGraph, Position
import unittest
from offsetbasedgraph import GraphWithReversals, Block
import json
from testdata import create_test_data, simple_graph
class TestGraph(unittest.TestCase):
def test_graph_from_json(self):
graph = Graph.from_file("tests/simple_graph.json")
self.assertEqual(len(graph.nodes), 3)
self.assertEqual(graph.nodes[0].id, 1)
self.assertEqual(graph.nodes[1].id, 2)
self.assertEqual(graph.nodes[2].id, 3)
self.assertEqual(graph.nodes[0].n_basepairs, 7)
self.assertEqual(graph.nodes[1].n_basepairs, 4)
self.assertEqual(graph.nodes[2].n_basepairs, 7)
self.assertEqual(graph.edges[0].from_node, 1)
self.assertEqual(graph.edges[0].to_node, 2)
self.assertEqual(graph.edges[0].from_start, False)
self.assertEqual(graph.edges[0].to_end, False)
self.assertEqual(graph.edges[1].from_node, 2)
self.assertEqual(graph.edges[1].to_node, 3)
self.assertEqual(graph.edges[1].from_start, False)
self.assertEqual(graph.edges[1].to_end, True)
def test_to_offset_based_graph(self):
graph = Graph.from_file("tests/simple_graph.json")
obgraph = graph.get_offset_based_graph()
self.assertEqual(obgraph, simple_graph)
class TestAlignment(unittest.TestCase):
def setUp(self):
self.alignment_json = '{"sequence": "TCCCCTTTTCCC", "identity": 0.75, "mapping_quality": 53, "path": {"name": "testread", "mapping": [{"rank": 1, "edit": [{"from_length": 5, "to_length": 5}], "position": {"offset": 2, "node_id": 1}}, {"rank": 2, "edit": [{"from_length": 4, "to_length": 4}, {"to_length": 3, "sequence": "CCC"}], "position": {"node_id": 2}}]}, "score": 9}'
def test_alignment_from_json(self):
alignment = Alignment.from_json(json.loads(self.alignment_json))
self.assertEqual(alignment.identity, 0.75)
path = alignment.path
self.assertEqual(path.name, "testread")
class TestProtoGraph(unittest.TestCase):
def test_from_file(self):
graph = ProtoGraph.from_vg_graph_file("tests/simple_graph.vg")
self.assertEqual(len(graph.nodes), 3)
class TestSnarls(unittest.TestCase):
def test_from_vg_file(self):
snarls = Snarls.from_vg_snarls_file("tests/snarls.pb")
snarlist = []
for snarl in snarls.snarls:
snarlist.append(snarl)
self.assertEqual(snarlist[0].start.node_id, 1)
self.assertEqual(snarlist[0].end.node_id, 2)
self.assertEqual(snarlist[1].start.node_id, 2)
self.assertEqual(snarlist[1].end.node_id, 3)
class TestPosition(unittest.TestCase):
def test_eq(self):
position1 = Position(3, 6)
position2 = Position(3, 6)
position3 = Position(3, 5)
self.assertEqual(position1, position2)
self.assertNotEqual(position1, position3)
if __name__ == "__main__":
create_test_data()
unittest.main()
| {"/pyvg/sequences.py": ["/pyvg/vgobjects.py"], "/tests/test_datastructures.py": ["/pyvg.py"], "/pyvg/alignmentcollection.py": ["/pyvg/conversion.py"], "/pyvg.py": ["/pyvg/alignmentcollection.py"], "/pyvg/__init__.py": ["/pyvg/vgobjects.py", "/pyvg/sequences.py", "/pyvg/util.py"], "/tests/test_conversion.py": ["/pyvg/conversion.py"], "/pyvg/construct.py": ["/pyvg/util.py"], "/pyvg/alignment.py": ["/pyvg/util.py"], "/tests/test_sequences.py": ["/pyvg/sequences.py"], "/pyvg/vgobjects.py": ["/pyvg.py"], "/pyvg/view.py": ["/pyvg/util.py"], "/pyvg/conversion.py": ["/pyvg/vgobjects.py"]} |
50,157 | khodor14/pyvg | refs/heads/master | /pyvg/alignmentcollection.py | import numpy as np
from .conversion import parse_vg_json_alignments
from collections import defaultdict
import pickle
from offsetbasedgraph import IntervalCollection
import logging
from graph_peak_caller.intervals import UniqueIntervals
logging.basicConfig(level=logging.DEBUG)
class AlignmentCollection:
def __init__(self, node_dict, graph, intervals):
self._node_dict = node_dict
self._graph = graph
self.intervals = intervals
@classmethod
def from_vg_json_file(cls, file_name, ob_graph):
alignments = parse_vg_json_alignments(file_name, ob_graph)
intervals = []
node_dict = defaultdict(set)
i = 0
for name, interval in alignments:
if i % 10000 == 0:
logging.info("#%d processed" % i)
for rp in interval.region_paths:
node_dict[rp].add((name, i))
intervals.append(interval)
i += 1
return cls(node_dict, ob_graph, intervals)
def to_file(self, file_name):
logging.info("Writing to file")
with open(file_name, "wb") as f:
pickle.dump(self._node_dict, f)
IntervalCollection(self.intervals).to_file(file_name + ".intervals")
@classmethod
def from_file(cls, file_name, graph):
logging.info("Reading from file")
logging.info("Reading dict structure")
with open(file_name, "rb") as f:
node_dict = pickle.load(f)
logging.info("Reading intervals")
intervals = IntervalCollection.from_file(file_name + ".intervals", graph=graph)
return cls(node_dict, graph, list(intervals))
def get_alignments_on_node(self, node_id):
return {name: self.intervals[index] for name, index in self._node_dict[node_id]}
def get_alignments_on_interval(self, interval):
alignments = {}
for node in interval.region_paths:
alignments.update(self.get_alignments_on_node(node))
alignments.update(self.get_alignments_on_node(-node))
return alignments
if __name__ == "__main__":
import sys
""""
def __init__(self, ob_graph, alignment_names, index_sizes, node_to_alignment_mapppings):
self.ob_graph = ob_graph
self.alignment_names = alignment_names
self.node_to_alignment_mappings = node_to_alignment_mapppings
@classmethod
def from_vg_json_file(cls, ob_graph, file_name):
alignments =
"""
| {"/pyvg/sequences.py": ["/pyvg/vgobjects.py"], "/tests/test_datastructures.py": ["/pyvg.py"], "/pyvg/alignmentcollection.py": ["/pyvg/conversion.py"], "/pyvg.py": ["/pyvg/alignmentcollection.py"], "/pyvg/__init__.py": ["/pyvg/vgobjects.py", "/pyvg/sequences.py", "/pyvg/util.py"], "/tests/test_conversion.py": ["/pyvg/conversion.py"], "/pyvg/construct.py": ["/pyvg/util.py"], "/pyvg/alignment.py": ["/pyvg/util.py"], "/tests/test_sequences.py": ["/pyvg/sequences.py"], "/pyvg/vgobjects.py": ["/pyvg.py"], "/pyvg/view.py": ["/pyvg/util.py"], "/pyvg/conversion.py": ["/pyvg/vgobjects.py"]} |
50,158 | khodor14/pyvg | refs/heads/master | /pyvg.py | import sys
from pyvg.alignmentcollection import AlignmentCollection
from offsetbasedgraph import Graph
import logging
if sys.argv[1] == "create_alignment_collection":
collection = AlignmentCollection.from_vg_json_file(sys.argv[2], Graph.from_file(sys.argv[3]))
collection.to_file(sys.argv[4])
logging.info("Wrote to file %s" % sys.argv[4])
| {"/pyvg/sequences.py": ["/pyvg/vgobjects.py"], "/tests/test_datastructures.py": ["/pyvg.py"], "/pyvg/alignmentcollection.py": ["/pyvg/conversion.py"], "/pyvg.py": ["/pyvg/alignmentcollection.py"], "/pyvg/__init__.py": ["/pyvg/vgobjects.py", "/pyvg/sequences.py", "/pyvg/util.py"], "/tests/test_conversion.py": ["/pyvg/conversion.py"], "/pyvg/construct.py": ["/pyvg/util.py"], "/pyvg/alignment.py": ["/pyvg/util.py"], "/tests/test_sequences.py": ["/pyvg/sequences.py"], "/pyvg/vgobjects.py": ["/pyvg.py"], "/pyvg/view.py": ["/pyvg/util.py"], "/pyvg/conversion.py": ["/pyvg/vgobjects.py"]} |
50,159 | khodor14/pyvg | refs/heads/master | /pyvg/__init__.py | from .vgobjects import Graph, Position, Edit, Path, Edge, Mapping, Node, Alignment, Snarls, ProtoGraph
from .sequences import SequenceRetriever
from .util import call_vg
| {"/pyvg/sequences.py": ["/pyvg/vgobjects.py"], "/tests/test_datastructures.py": ["/pyvg.py"], "/pyvg/alignmentcollection.py": ["/pyvg/conversion.py"], "/pyvg.py": ["/pyvg/alignmentcollection.py"], "/pyvg/__init__.py": ["/pyvg/vgobjects.py", "/pyvg/sequences.py", "/pyvg/util.py"], "/tests/test_conversion.py": ["/pyvg/conversion.py"], "/pyvg/construct.py": ["/pyvg/util.py"], "/pyvg/alignment.py": ["/pyvg/util.py"], "/tests/test_sequences.py": ["/pyvg/sequences.py"], "/pyvg/vgobjects.py": ["/pyvg.py"], "/pyvg/view.py": ["/pyvg/util.py"], "/pyvg/conversion.py": ["/pyvg/vgobjects.py"]} |
50,160 | khodor14/pyvg | refs/heads/master | /tests/test_conversion.py | import unittest
from pyvg.conversion import vg_json_file_to_interval_collection, json_file_to_obg_numpy_graph
from testdata import create_test_data, simple_graph
class TestReadConversion(unittest.TestCase):
def setUp(self):
reads = '{"sequence": "CCTTTTCCC", "identity": 0.75, "mapping_quality": 53, "path": {"name": "testread", "mapping": [{"rank": 1, "edit": [{"from_length": 5, "to_length": 5}], "position": {"offset": 2, "node_id": 1}}, {"rank": 2, "edit": [{"from_length": 4, "to_length": 4}, {"to_length": 3, "sequence": "CCC"}], "position": {"node_id": 2}}]}, "score": 9}'
reads += "\n"
reads += '{"sequence": "CCTTTTCCC", "identity": 0.8, "mapping_quality": 60, "path": {"name": "testread", "mapping": [{"rank": 1, "edit": [{"from_length": 5, "to_length": 5}], "position": {"offset": 2, "node_id": 1}}, {"rank": 2, "edit": [{"from_length": 4, "to_length": 4}, {"to_length": 3, "sequence": "CCC"}], "position": {"node_id": 2}}]}, "score": 9}'
f = open("alignments.json", "w")
f.write(reads)
f.close()
self.graph = simple_graph
def test_json_reads_to_intervalcollection(self):
intervals = vg_json_file_to_interval_collection("alignments.json", self.graph)
intervals = intervals.intervals
for interval in intervals:
assert interval.length() == 9
class TestGraphConversion(unittest.TestCase):
def test_simple(self):
graph = json_file_to_obg_numpy_graph("tests/simple_graph.json")
assert graph == simple_graph
if __name__ == "__main__":
create_test_data()
unittest.main() | {"/pyvg/sequences.py": ["/pyvg/vgobjects.py"], "/tests/test_datastructures.py": ["/pyvg.py"], "/pyvg/alignmentcollection.py": ["/pyvg/conversion.py"], "/pyvg.py": ["/pyvg/alignmentcollection.py"], "/pyvg/__init__.py": ["/pyvg/vgobjects.py", "/pyvg/sequences.py", "/pyvg/util.py"], "/tests/test_conversion.py": ["/pyvg/conversion.py"], "/pyvg/construct.py": ["/pyvg/util.py"], "/pyvg/alignment.py": ["/pyvg/util.py"], "/tests/test_sequences.py": ["/pyvg/sequences.py"], "/pyvg/vgobjects.py": ["/pyvg.py"], "/pyvg/view.py": ["/pyvg/util.py"], "/pyvg/conversion.py": ["/pyvg/vgobjects.py"]} |
50,161 | khodor14/pyvg | refs/heads/master | /pyvg/construct.py | from .util import call_vg
import logging
def construct_graph_from_msa(msa_file, out_file_name):
call_vg("vg construct -M %s -F fasta" % (msa_file), False, out_file_name + ".tmp")
call_vg("vg mod -c %s" % out_file_name + ".tmp", False, out_file_name + "-2.tmp")
call_vg("vg mod -s %s" % out_file_name + "-2.tmp", False, out_file_name)
logging.info("Done constructing graph, wrote to %s" % out_file_name) | {"/pyvg/sequences.py": ["/pyvg/vgobjects.py"], "/tests/test_datastructures.py": ["/pyvg.py"], "/pyvg/alignmentcollection.py": ["/pyvg/conversion.py"], "/pyvg.py": ["/pyvg/alignmentcollection.py"], "/pyvg/__init__.py": ["/pyvg/vgobjects.py", "/pyvg/sequences.py", "/pyvg/util.py"], "/tests/test_conversion.py": ["/pyvg/conversion.py"], "/pyvg/construct.py": ["/pyvg/util.py"], "/pyvg/alignment.py": ["/pyvg/util.py"], "/tests/test_sequences.py": ["/pyvg/sequences.py"], "/pyvg/vgobjects.py": ["/pyvg.py"], "/pyvg/view.py": ["/pyvg/util.py"], "/pyvg/conversion.py": ["/pyvg/vgobjects.py"]} |
50,162 | khodor14/pyvg | refs/heads/master | /pyvg/alignment.py | import re
import io
from itertools import islice, chain
from .util import call_vg
from Bio.SeqIO.FastaIO import SimpleFastaParser
from subprocess import Popen, PIPE, check_output
import logging
def fasta_parser(file_name):
with open(file_name) as f:
for title, sequence in SimpleFastaParser(f):
yield title, sequence
def align_safe(sequence_id, sequence, vg_graph_file_name):
command = "vg align -Q %s -s %s %s" % (sequence_id, sequence,
vg_graph_file_name)
align_process = Popen(command.split(), stdout=PIPE)
command = "vg view -aj -"
view_process = Popen(command.split(), stdin=align_process.stdout,
stdout=PIPE)
return io.TextIOWrapper(view_process.stdout)
def align_sequence(sequence_id, sequence, vg_graph_file_name):
vg_alignment = call_vg("vg align -Q %s -s %s %s" % (sequence_id, sequence, vg_graph_file_name),
return_raw=True)
with open("tmp.vg", "wb") as tmp_file:
tmp_file.write(vg_alignment)
json_alignment = call_vg("vg view -aj 80tmp.vg")
return json_alignment
def align_fasta_to_graph(fasta_file_name, graph_file_name, out_file_name):
output_file = open(out_file_name, "w")
for title, sequence in fasta_parser(fasta_file_name):
print("Aligning %s" % title)
json_alignment = align_sequence("%s" % title.split()[0], sequence, graph_file_name)
name_search = re.search(r"\"name\":\"([A-Z0-9_\-\.a-z]+)+\"", json_alignment, re.IGNORECASE)
if name_search:
name = name_search.group(1)
else:
raise Exception("Did not found name")
print(" Matched %s" % name)
output_file.writelines([json_alignment])
output_file.close()
logging.info("Wrote to %s" % out_file_name)
def _chunks(iterator, N):
for first in iterator:
yield chain([first], islice(iterator, N-1))
def align_fasta_to_graph_paralell(fasta_file_name, graph_file_name, out_file_name):
output_file = open(out_file_name, "w")
def assert_name(name, json_alignment):
try:
found_name = re.search(r"\"name\": ?\"([A-Z0-9_\-\.a-z]+)+\"",
json_alignment, re.IGNORECASE).group(1)
except AttributeError as e:
print("Search for name gave no results for %s" % json_alignment)
raise
assert found_name == name or found_name == name.split()[0], (name, found_name)
return json_alignment
output_file = open(out_file_name, "w")
for chunk in _chunks(fasta_parser(fasta_file_name), 100):
pipes = {title: align_safe(title.split()[0], sequence, graph_file_name)
for title, sequence in chunk}
alignments = (assert_name(title, str(pipe.read()))
for title, pipe in pipes.items())
output_file.writelines(alignments)
output_file.close()
logging.info("Wrote to %s" % out_file_name)
| {"/pyvg/sequences.py": ["/pyvg/vgobjects.py"], "/tests/test_datastructures.py": ["/pyvg.py"], "/pyvg/alignmentcollection.py": ["/pyvg/conversion.py"], "/pyvg.py": ["/pyvg/alignmentcollection.py"], "/pyvg/__init__.py": ["/pyvg/vgobjects.py", "/pyvg/sequences.py", "/pyvg/util.py"], "/tests/test_conversion.py": ["/pyvg/conversion.py"], "/pyvg/construct.py": ["/pyvg/util.py"], "/pyvg/alignment.py": ["/pyvg/util.py"], "/tests/test_sequences.py": ["/pyvg/sequences.py"], "/pyvg/vgobjects.py": ["/pyvg.py"], "/pyvg/view.py": ["/pyvg/util.py"], "/pyvg/conversion.py": ["/pyvg/vgobjects.py"]} |
50,163 | khodor14/pyvg | refs/heads/master | /tests/test_sequences.py | import unittest
from pyvg.sequences import SequenceRetriever
from offsetbasedgraph import Interval
from testdata import create_test_data
class TestSequences(unittest.TestCase):
def _test_from_vg_graph(self):
retriever = SequenceRetriever.from_vg_graph("cactus-mhc.vg")
def setUp(self):
self.nodes = {
1: "AAG",
2: "GAA",
3: "AGA"
}
self.retriever = SequenceRetriever(self.nodes)
def test_single_node_interval(self):
interval = Interval(0, 3, [1])
self.assertEqual(self.retriever.get_interval_sequence(interval),
self.nodes[1])
def test_single_node_interval_with_offset(self):
interval = Interval(1, 3, [1])
self.assertEqual(self.retriever.get_interval_sequence(interval),
"AG")
def test_single_node_interval_with_dual_offset(self):
interval = Interval(1, 2, [1])
self.assertEqual(self.retriever.get_interval_sequence(interval),
"A")
def test_reversed_single_node_interval(self):
interval = Interval(0, 3, [-1])
self.assertEqual(self.retriever.get_interval_sequence(interval),
"CTT")
def test_reversed_single_node_interval_with_dual_offsetl(self):
interval = Interval(1, 2, [-3])
self.assertEqual(self.retriever.get_interval_sequence(interval),
"C")
def test_multiple_nodes_interval(self):
interval = Interval(0, 3, [1, 2])
self.assertEqual(self.retriever.get_interval_sequence(interval),
"AAGGAA")
def test_multiple_nodes_interval_second_rp_reversed(self):
interval = Interval(0, 3, [1, -2])
self.assertEqual(self.retriever.get_interval_sequence(interval),
"AAGTTC")
def test_long_interval(self):
interval = Interval(1, 1, [1, 2, 3, -3, -2, -1])
self.assertEqual(self.retriever.get_interval_sequence(interval),
"AGGAAAGATCTTTCC")
def test_from_vg_json_graph(self):
retriever = SequenceRetriever.from_vg_json_graph("tests/simple_graph.json")
self.assertEqual(retriever.get_sequence(1, 0, 7), "tttcccc")
if __name__ == "__main__":
create_test_data()
unittest.main()
| {"/pyvg/sequences.py": ["/pyvg/vgobjects.py"], "/tests/test_datastructures.py": ["/pyvg.py"], "/pyvg/alignmentcollection.py": ["/pyvg/conversion.py"], "/pyvg.py": ["/pyvg/alignmentcollection.py"], "/pyvg/__init__.py": ["/pyvg/vgobjects.py", "/pyvg/sequences.py", "/pyvg/util.py"], "/tests/test_conversion.py": ["/pyvg/conversion.py"], "/pyvg/construct.py": ["/pyvg/util.py"], "/pyvg/alignment.py": ["/pyvg/util.py"], "/tests/test_sequences.py": ["/pyvg/sequences.py"], "/pyvg/vgobjects.py": ["/pyvg.py"], "/pyvg/view.py": ["/pyvg/util.py"], "/pyvg/conversion.py": ["/pyvg/vgobjects.py"]} |
50,164 | khodor14/pyvg | refs/heads/master | /pyvg/vgobjects.py | import json
import logging
import os
import pickle
from collections import defaultdict
import offsetbasedgraph
import stream
from pyvg import vg_pb2
class IntervalNotInGraphException(Exception):
pass
class Position(object):
def __init__(self, node_id, offset, is_reverse=False):
self.node_id = node_id
self.offset = offset
self.is_reverse = is_reverse
def __eq__(self, other):
if self.node_id != other.node_id:
return False
if self.offset != other.offset:
return False
return self.is_reverse == other.is_reverse
def __str__(self):
return "Pos(%s, %s, %s)" % (self.node_id, self.offset, self.is_reverse)
__repr__ = __str__
def to_obg(self):
return offsetbasedgraph.Position(self.node_id, self.offset)
@classmethod
def from_json(cls, position_dict):
offset = int(position_dict["offset"]) if "offset" in position_dict else 0
node_id = int(position_dict["node_id"])
is_reverse = False
if "is_reverse" in position_dict:
is_reverse = position_dict["is_reverse"]
return cls(node_id, offset, is_reverse)
class Edit(object):
def __init__(self, to_length, from_length, sequence):
self.to_length = to_length
self.from_length = from_length
self.sequence = sequence
@classmethod
def from_proto_obj(cls, obj):
return cls(obj.to_length, obj.from_length, obj.sequence)
def __eq__(self, other):
attrs = ["to_length", "from_length", "sequence"]
return all(getattr(self, attr) == getattr(other, attr)
for attr in attrs)
def is_identity(self):
return self.to_length == self.from_length and not self.sequence
@classmethod
def from_json(cls, edit_dict, skip_sequence=False):
sequence = None
if not skip_sequence:
sequence = None if "sequence" not in edit_dict else edit_dict["sequence"]
to_length = edit_dict["to_length"] if "to_length" in edit_dict else 0
from_length = edit_dict["from_length"] if "from_length" in edit_dict else 0
return cls(to_length, from_length, sequence)
class Mapping(object):
def __init__(self, start_position, edits):
self.start_position = start_position
self.edits = edits
def is_identity(self):
return all(edit.is_identity() for edit in self.edits)
def __eq__(self, other):
attrs = ["start_position", "edits"]
return all(getattr(self, attr) == getattr(other, attr)
for attr in attrs)
def __str__(self):
return "Map(%s, %s)" % (
self.start_position, self.length())
def node_id(self):
if self.is_reverse():
return -int(self.start_position.node_id)
return int(self.start_position.node_id)
def length(self):
return sum(edit.from_length for edit in self.edits)
def is_reverse(self):
return self.start_position.is_reverse
def get_start_offset(self):
return self.start_position.offset
def get_end_offset(self):
start_offset = self.start_position.offset
return start_offset + self.length()
@classmethod
def from_json(cls, mapping_dict):
start_position = Position.from_json(mapping_dict["position"])
edits = []
if "edit" in mapping_dict:
try:
edits = [Edit.from_json(edit, skip_sequence=False) for edit in mapping_dict["edit"]]
except KeyError:
logging.error(mapping_dict)
raise
return cls(start_position, edits)
class Path(object):
def __init__(self, name, mappings):
self.mappings = mappings
self.name = name
def is_identity(self):
return all(mapping.is_identity() for mapping in self.mappings)
def __eq__(self, other):
attrs = ["mappings"]
return all(getattr(self, attr) == getattr(other, attr)
for attr in attrs)
def __str__(self):
return "Path[%s]" % ", ".join(
str(mapping) for mapping in self.mappings)
__repr__ = __str__
def is_reverse(self):
mapping_reverse = [mapping.is_reverse() for mapping in self.mappings]
assert all(is_reverse == mapping_reverse[0] for is_reverse in mapping_reverse), mapping_reverse
return mapping_reverse[0]
@classmethod
def from_json(cls, path_dict):
name = path_dict["name"] if "name" in path_dict else None
mappings = []
if "mapping" in path_dict:
mappings = [Mapping.from_json(mapping) for
mapping in path_dict["mapping"]]
return cls(name, mappings)
def to_obg_with_reversals(self, ob_graph=False):
if len(self.mappings) == 0:
return False
start_offset = self.mappings[0].get_start_offset()
end_offset = self.mappings[-1].get_end_offset()
obg_blocks = [m.node_id() for m in self.mappings]
interval = offsetbasedgraph.DirectedInterval(
start_offset, end_offset,
obg_blocks, ob_graph or None)
if ob_graph:
if not interval.length() == self.length():
raise IntervalNotInGraphException("Interval %s is not valid interval in graph" % interval)
return interval
def length(self):
return sum(mapping.length() for mapping in self.mappings)
def to_obg(self, ob_graph=False):
assert ob_graph is not None
return self.to_obg_with_reversals(ob_graph=ob_graph)
class Node(object):
def __init__(self, name, id, n_basepairs):
self.name = name
self.id = id
self.n_basepairs = n_basepairs
def __str__(self):
return "Node(%s, %s)" % (self.id, self.n_basepairs)
__repr__ = __str__
@classmethod
def from_json(cls, json_object):
name = ""
if "name" in json_object:
name = json_object["name"]
return cls(name, json_object["id"], len(json_object["sequence"]))
def to_obg(self):
return offsetbasedgraph.Block(self.n_basepairs)
class Edge(object):
def __init__(self, from_node, to_node, from_start=False, to_end=False, overlap=0):
self.from_node = from_node
self.to_node = to_node
self.from_start = int(from_start)
self.to_end = int(to_end)
self.overlap = int(overlap)
@classmethod
def from_json(cls, json_object):
from_start = False
to_end = False
overlap = 0
if "from_start" in json_object:
from_start = json_object["from_start"]
# Parsed by json == "True" # NB: Is True correct?
if "to_end" in json_object:
to_end = json_object["to_end"] # == "True"
if "overlap" in json_object:
overlap = int(json_object["overlap"])
return cls(int(json_object["from"]),
int(json_object["to"]),
from_start,
to_end,
overlap,
)
def get_from_node(self):
if self.from_start:
return -1*self.from_node
return self.from_node
def get_to_node(self):
if self.to_end:
return -1 * self.to_node
return self.to_node
class Alignment(object):
def __init__(self, path, identity, score=0, refpos=0, chromosome=None, mapq=0, name=None):
self.identity = identity
self.path = path
self.score = score
self.refpos = refpos
self.chromosome = chromosome
self.mapq = mapq
self.name = name
@classmethod
def from_json(cls, alignment_dict):
try:
offset = int(alignment_dict["refpos"][0]["offset"])
chromosome = alignment_dict["refpos"][0]["name"]
except KeyError:
logging.warning("Could not get offset from alignment. Defaulting to 0 instead.")
offset = 0
chromosome = None
return cls(
Path.from_json(alignment_dict["path"]),
alignment_dict["identity"] if "identity" in alignment_dict else None,
int(alignment_dict["score"]) if "score" in alignment_dict else None,
offset,
chromosome,
int(alignment_dict["mapping_quality"]) if "mapping_quality" in alignment_dict else None,
name=alignment_dict["name"] if "name" in alignment_dict else None
)
class Snarls(object):
def __init__(self, snarls):
self.snarls = snarls
@classmethod
def from_vg_snarls_file(cls, vg_snarls_file_name):
snarls = (snarl for snarl in
stream.parse(vg_snarls_file_name, vg_pb2.Snarl))
return cls(snarls)
class ProtoGraph(object):
"""
Holding a vg proto graph (restructured into list of nodes, edges and paths.
Warning: Python proto reading is slow. Graph class reads from json and is faster.
"""
def __init__(self, nodes, edges, paths):
self.nodes = nodes
self.edges = edges
self.paths = paths
@classmethod
def from_vg_graph_file(cls, vg_graph_file_name, only_read_nodes=False,
use_cache_if_available=False):
nodes = {}
paths = []
edges = []
i = 0
for line in stream.parse(vg_graph_file_name, vg_pb2.Graph):
i += 1
if hasattr(line, "node"):
for node in line.node:
nodes[node.id] = node.sequence
if only_read_nodes:
continue
if hasattr(line, "path"):
for path in line.path:
paths.append(path)
if hasattr(line, "edge"):
for edge in line.edge:
assert edge.overlap == 0
graph = cls(nodes, edges, paths)
graph._cache_nodes()
return graph
@classmethod
def from_node_dict(cls, node_dict):
"""Create a dummy object from a node dict (node id => sequence)"""
return cls(node_dict, [], [])
def _cache_nodes(self):
with open("%s" % "vg_sequence_index.cached", "wb") as f:
pickle.dump(self.nodes, f)
class Graph(object):
def __init__(self, nodes, edges, paths):
self.nodes = nodes
self.edges = edges
self.paths = paths
self.node_dict = {node.id: node.n_basepairs for node in self.nodes}
self.edge_dict = {}
self.reverse_edge_dict = {}
self._create_edge_dicts()
@classmethod
def from_file(cls, json_file_name, do_read_paths=True):
logging.info("Reading vg graph from json file %s" % json_file_name)
paths = []
edges = []
nodes = []
f = open(json_file_name)
lines = f.readlines()
n_lines = len(lines)
# object_types = ["Path", "Edge", "Node"]
i = 1
for line in lines:
line = json.loads(line)
i += 1
if do_read_paths and "path" in line:
paths.extend([Path.from_json(json_object) for json_object in line["path"]])
if "node" in line:
nodes.extend([Node.from_json(json_object) for json_object in line["node"]])
if "edge" in line:
edges.extend([Edge.from_json(json_object) for json_object in line["edge"]])
obj = cls(nodes, edges, paths)
if do_read_paths:
obj.paths_as_intervals_by_chr = {}
logging.info("Done reading vg graph")
return obj
def _create_edge_dicts(self):
self.edge_dict = defaultdict(list)
self.reverse_edge_dict = defaultdict(list)
for edge in self.edges:
self.edge_dict[edge.get_from_node()].append(edge.get_to_node())
self.reverse_edge_dict[-edge.get_to_node()].append(-edge.get_from_node())
def filter(self, objects):
return [obj for obj in objects if self.is_in_graph(obj)]
def edges_from_node(self, node_id):
return self.edge_dict[node_id]
def get_offset_based_graph(self):
offset_based_edges = defaultdict(list)
for edge in self.edges:
from_node = edge.from_node
to_node = edge.to_node
if edge.from_start:
from_node = -from_node
if edge.to_end:
to_node = -to_node
offset_based_edges[from_node].append(to_node)
offset_based_blocks = {}
for block in self.nodes:
offset_based_blocks[block.id] = block.to_obg()
return offsetbasedgraph.GraphWithReversals(
offset_based_blocks,
offset_based_edges)
| {"/pyvg/sequences.py": ["/pyvg/vgobjects.py"], "/tests/test_datastructures.py": ["/pyvg.py"], "/pyvg/alignmentcollection.py": ["/pyvg/conversion.py"], "/pyvg.py": ["/pyvg/alignmentcollection.py"], "/pyvg/__init__.py": ["/pyvg/vgobjects.py", "/pyvg/sequences.py", "/pyvg/util.py"], "/tests/test_conversion.py": ["/pyvg/conversion.py"], "/pyvg/construct.py": ["/pyvg/util.py"], "/pyvg/alignment.py": ["/pyvg/util.py"], "/tests/test_sequences.py": ["/pyvg/sequences.py"], "/pyvg/vgobjects.py": ["/pyvg.py"], "/pyvg/view.py": ["/pyvg/util.py"], "/pyvg/conversion.py": ["/pyvg/vgobjects.py"]} |
50,165 | khodor14/pyvg | refs/heads/master | /tests/testdata.py | from offsetbasedgraph import GraphWithReversals, Block
def create_test_data():
simple_graph = """
{
"node": [
{"id": 1, "sequence": "TTTCCCC"},
{"id": 2, "sequence": "TTTT"},
{"id": 3, "sequence": "CCCCTTT"}
],
"edge": [
{"from": 1, "to": 2},
{"from": 2, "to": 3, "to_end": true}
]
}
"""
f = open("simple_graph.json", "w")
f.write(simple_graph.replace("\n", " "))
f.close()
simple_graph = GraphWithReversals({
1: Block(7),
2: Block(4),
3: Block(7)
},
{
1: [2],
2: [-3]
})
| {"/pyvg/sequences.py": ["/pyvg/vgobjects.py"], "/tests/test_datastructures.py": ["/pyvg.py"], "/pyvg/alignmentcollection.py": ["/pyvg/conversion.py"], "/pyvg.py": ["/pyvg/alignmentcollection.py"], "/pyvg/__init__.py": ["/pyvg/vgobjects.py", "/pyvg/sequences.py", "/pyvg/util.py"], "/tests/test_conversion.py": ["/pyvg/conversion.py"], "/pyvg/construct.py": ["/pyvg/util.py"], "/pyvg/alignment.py": ["/pyvg/util.py"], "/tests/test_sequences.py": ["/pyvg/sequences.py"], "/pyvg/vgobjects.py": ["/pyvg.py"], "/pyvg/view.py": ["/pyvg/util.py"], "/pyvg/conversion.py": ["/pyvg/vgobjects.py"]} |
50,166 | khodor14/pyvg | refs/heads/master | /pyvg/graphstats.py | from offsetbasedgraph import NumpyIndexedInterval, Graph
import sys
def count_variants_in_graph(graph, linear_path):
reference_nodes = linear_path.nodes_in_interval()
n_variants = 0
i = 0
for node in graph.blocks:
if i % 1000000 == 0:
print("Node #%d" % i)
i += 1
if node not in reference_nodes:
continue
n_variants += max(0, len(graph.adj_list[node]) - 1)
print("Variants: %d" % n_variants)
return n_variants
if __name__ == "__main__":
n_variants = 0
for chromosome in sys.argv[2].split(","):
print("Chromosome %s" % chromosome)
graph = Graph.from_file(sys.argv[1] + "/" + chromosome + "_pruned.nobg")
linear_path = NumpyIndexedInterval.from_file(sys.argv[1] + "/" + chromosome + "_linear_pathv2.interval")
n_variants += count_variants_in_graph(graph, linear_path)
print("Total: %d" % n_variants) | {"/pyvg/sequences.py": ["/pyvg/vgobjects.py"], "/tests/test_datastructures.py": ["/pyvg.py"], "/pyvg/alignmentcollection.py": ["/pyvg/conversion.py"], "/pyvg.py": ["/pyvg/alignmentcollection.py"], "/pyvg/__init__.py": ["/pyvg/vgobjects.py", "/pyvg/sequences.py", "/pyvg/util.py"], "/tests/test_conversion.py": ["/pyvg/conversion.py"], "/pyvg/construct.py": ["/pyvg/util.py"], "/pyvg/alignment.py": ["/pyvg/util.py"], "/tests/test_sequences.py": ["/pyvg/sequences.py"], "/pyvg/vgobjects.py": ["/pyvg.py"], "/pyvg/view.py": ["/pyvg/util.py"], "/pyvg/conversion.py": ["/pyvg/vgobjects.py"]} |
50,167 | khodor14/pyvg | refs/heads/master | /pyvg/util.py | import os
import subprocess
import logging
def call_vg(command, return_raw=False, out_file=None):
logging.debug("Running vg command: " + command)
if out_file is not None:
with open(out_file, "w") as outfile:
subprocess.call(command.split(), stdout=outfile)
logging.info("Wrote to %s" % out_file)
return
res = subprocess.check_output(command.split())
if res == "" or return_raw:
return res
return res.decode("utf-8")
def get_stats(graph_file_name):
stats = call_vg("vg stats -lz %s" % graph_file_name)
lines = stats.split("\n")
return {
"nodes": lines[0].split()[1],
"edges": lines[1].split()[1],
"length": lines[2].split()[1],
}
| {"/pyvg/sequences.py": ["/pyvg/vgobjects.py"], "/tests/test_datastructures.py": ["/pyvg.py"], "/pyvg/alignmentcollection.py": ["/pyvg/conversion.py"], "/pyvg.py": ["/pyvg/alignmentcollection.py"], "/pyvg/__init__.py": ["/pyvg/vgobjects.py", "/pyvg/sequences.py", "/pyvg/util.py"], "/tests/test_conversion.py": ["/pyvg/conversion.py"], "/pyvg/construct.py": ["/pyvg/util.py"], "/pyvg/alignment.py": ["/pyvg/util.py"], "/tests/test_sequences.py": ["/pyvg/sequences.py"], "/pyvg/vgobjects.py": ["/pyvg.py"], "/pyvg/view.py": ["/pyvg/util.py"], "/pyvg/conversion.py": ["/pyvg/vgobjects.py"]} |
50,168 | khodor14/pyvg | refs/heads/master | /pyvg/view.py | import logging
from .util import call_vg
def graph_to_json(graph_file_name, json_file_name):
call_vg("vg view -Vj %s" % graph_file_name, out_file=json_file_name)
logging.info("Done converting to json. Wrote to %s" % json_file_name)
| {"/pyvg/sequences.py": ["/pyvg/vgobjects.py"], "/tests/test_datastructures.py": ["/pyvg.py"], "/pyvg/alignmentcollection.py": ["/pyvg/conversion.py"], "/pyvg.py": ["/pyvg/alignmentcollection.py"], "/pyvg/__init__.py": ["/pyvg/vgobjects.py", "/pyvg/sequences.py", "/pyvg/util.py"], "/tests/test_conversion.py": ["/pyvg/conversion.py"], "/pyvg/construct.py": ["/pyvg/util.py"], "/pyvg/alignment.py": ["/pyvg/util.py"], "/tests/test_sequences.py": ["/pyvg/sequences.py"], "/pyvg/vgobjects.py": ["/pyvg.py"], "/pyvg/view.py": ["/pyvg/util.py"], "/pyvg/conversion.py": ["/pyvg/vgobjects.py"]} |
50,169 | khodor14/pyvg | refs/heads/master | /pyvg/conversion.py | import json
import logging
from collections import defaultdict
import offsetbasedgraph as obg
from offsetbasedgraph import IntervalCollection
from .vgobjects import Graph, Alignment, Path, Mapping, Edit
import numpy as np
logger = logging.getLogger(__name__)
def get_json_lines(filename):
with open(filename, "r") as f:
for line in f:
try:
yield json.loads(line)
except json.decoder.JSONDecodeError as e:
logging.error("Fail when parsing vg json. Skipping this line and continuing: " + str(e) + "")
continue
except UnicodeDecodeError as e:
logging.error("Unicode parsing fail when parsing vg json. Skipping this line and continuing: " + str(e) + "")
continue
def get_json_paths_from_json(filename):
with open(filename) as f:
for line in f:
try:
yield json.loads(line)["path"]
except json.decoder.JSONDecodeError as e:
logging.error("Fail when parsing vg path json. Skipping this line and continuing: " + str(e) + "")
continue
except KeyError as e:
logging.error("Did not find path in alignment. Assuming this is mis-alignment: " + str(e) + "")
def parse_vg_json_alignments(mapping_file_name, ob_graph, include_score=False):
json_objects = get_json_lines(mapping_file_name)
alignments = (Alignment.from_json(json_object) for json_object in json_objects)
if include_score:
return ((alignment.name, alignment.path.to_obg_with_reversals(ob_graph),
alignment.score, alignment.mapq, alignment.refpos, alignment.chromosome) for alignment in alignments)
return ((alignment.name, alignment.path.to_obg_with_reversals(ob_graph)) for alignment in alignments)
def vg_json_file_to_intervals(mapping_file_name, ob_graph=None, filter_funcs=()):
logging.info("Initing json reads as generator from: %s" % mapping_file_name)
json_paths = get_json_paths_from_json(mapping_file_name)
paths = (Path.from_json(json_path) for json_path in json_paths)
paths = (path for path in paths if
all(filter_func(path) for filter_func in filter_funcs))
intervals = (path.to_obg_with_reversals(ob_graph) for path in paths)
return (i for i in intervals if i is not False)
def vg_json_file_to_interval_collection(vg_mapping_file_name, offset_based_graph=None):
return obg.IntervalCollection(vg_json_file_to_intervals(vg_mapping_file_name, offset_based_graph))
def json_file_to_obg_numpy_graph(json_file_name, n_nodes = 0):
"""
Faster method not using Graph class. Directly converts to a
numpy-backed Offset Based Graph.
"""
logging.info("Creating ob graph from json file")
adj_list = defaultdict(list)
rev_adj_list = defaultdict(list)
i = 0
min_node_id = 1e15
max_node_id = 0
# Find max and minh
with open(json_file_name) as f:
lines = f
json_objs = (json.loads(line) for line in lines)
has_warned_about_int = False
for json_obj in json_objs:
if "node" in json_obj:
for node in json_obj["node"]:
id = node["id"]
if not isinstance(id, int):
if not has_warned_about_int:
logging.warning("Node id %s is not int. Converting to int when creating graph." % id)
has_warned_about_int = True
id = int(id)
if id < min_node_id:
min_node_id = id
if id > max_node_id:
max_node_id = id
logging.info("Min node: %d, Max node: %d" % (min_node_id, max_node_id))
nodes = np.zeros((max_node_id - min_node_id) + 2, dtype=np.uint16)
logging.info("Reading from json")
with open(json_file_name) as f:
lines = f
json_objs = (json.loads(line) for line in lines)
for json_obj in json_objs:
if "node" in json_obj:
for node in json_obj["node"]:
nodes[int(node["id"]) - min_node_id + 1] = len(node["sequence"])
if "edge" in json_obj:
for edge in json_obj["edge"]:
if "from_start" in edge and edge["from_start"] and "to_end" in edge and edge["to_end"]:
# new in vg 1.27, this is a normal edge from end to start
from_node = int(edge["to"])
to_node = int(edge["from"])
assert from_node >= 0 and to_node >= 0
else:
from_node = -int(edge["from"]) if "from_start" in edge and edge["from_start"] else edge["from"]
to_node = -int(edge["to"]) if "to_end" in edge and edge["to_end"] else edge["to"]
adj_list[int(from_node)].append(to_node)
rev_adj_list[-int(to_node)].append(-int(from_node))
logging.info("Creating numpy adj lists")
adj_list = obg.graph.AdjListAsNumpyArrays.create_from_edge_dict(adj_list)
rev_adj_list = obg.graph.AdjListAsNumpyArrays.create_from_edge_dict(rev_adj_list)
graph = obg.GraphWithReversals(nodes, adj_list,
rev_adj_list=rev_adj_list,
create_reverse_adj_list=False)
graph.blocks.node_id_offset = min_node_id - 1
return graph
| {"/pyvg/sequences.py": ["/pyvg/vgobjects.py"], "/tests/test_datastructures.py": ["/pyvg.py"], "/pyvg/alignmentcollection.py": ["/pyvg/conversion.py"], "/pyvg.py": ["/pyvg/alignmentcollection.py"], "/pyvg/__init__.py": ["/pyvg/vgobjects.py", "/pyvg/sequences.py", "/pyvg/util.py"], "/tests/test_conversion.py": ["/pyvg/conversion.py"], "/pyvg/construct.py": ["/pyvg/util.py"], "/pyvg/alignment.py": ["/pyvg/util.py"], "/tests/test_sequences.py": ["/pyvg/sequences.py"], "/pyvg/vgobjects.py": ["/pyvg.py"], "/pyvg/view.py": ["/pyvg/util.py"], "/pyvg/conversion.py": ["/pyvg/vgobjects.py"]} |
50,200 | stevenlandis/SBHACKS_V | refs/heads/master | /dragonIO/testAll/Volume_Control.py | from sound import Sound
def Change_Volume(direction):
if int(direction) == 1:
Increase_Volume()
else:
Decrease_Volume()
def Increase_Volume():
Sound.volume_up()
def Decrease_Volume():
Sound.volume_down()
def Mute():
Sound.mute()
def Max_Volume():
Sound.volume_max()
def Min_Volume():
Sound.volume_min()
def Get_Volume():
return Sound.current_volume()
def Set_Volume(amount):
Sound.volume_set(amount/1023*100)
| {"/dragonIO/testAll/GUI.py": ["/Youtube_Control.py"], "/Receive.py": ["/Youtube_Control.py"]} |
50,201 | stevenlandis/SBHACKS_V | refs/heads/master | /dragonIO/testAll/Windows_Control.py | import wmi
import pywin32_system32
import sys
import os
def Change_Brightness(brightness):
try:
turnVal = round(brightness / 1023 * 100)
c = wmi.WMI(namespace='wmi')
methods = c.WmiMonitorBrightnessMethods()[0]
print('setting brightness to {}'.format(turnVal))
methods.WmiSetBrightness(turnVal, 0)
except Exception as e:
print(e)
brightState = 'light'
def Toggle_Brightness(brightness):
if brightness == 0:
return
global brightState
try:
if brightState == 'dark':
brightState = 'light'
Change_Brightness(1023)
else:
brightState = 'dark'
Change_Brightness(0)
except Exception as e:
print(e)
def Auto_Brightness(brightness):
Change_Brightness(brightness)
| {"/dragonIO/testAll/GUI.py": ["/Youtube_Control.py"], "/Receive.py": ["/Youtube_Control.py"]} |
50,202 | stevenlandis/SBHACKS_V | refs/heads/master | /dragonIO/testAll/GUI.py | from tkinter import *
import Keyboard_Control as keyboard
import Windows_Control as windows
import Volume_Control as volume
import Youtube_Control as youtube
def nothing(arg):
pass
Function_Dict = {"rot":volume.Set_Volume ,
"touch": youtube.Open_Youtube,
"light": nothing,
"button": windows.Toggle_Brightness,
"click": keyboard.Enter,
"encoder": keyboard.Scroll_Windows}
def GUI():
rotItem = ''
touchItem = ''
lightItem = ''
buttonActItem = ''
clickItem = ''
encoderItem = ''
tk = Tk()
tk.title("Sensors and Actions")
tk.geometry("300x250+300+200")
rotVar = StringVar(tk)
touchVar = StringVar(tk)
lightVar= StringVar(tk)
buttonActVar = StringVar(tk)
clickVar = StringVar(tk)
encoderVar = StringVar(tk)
rotVar.set("Volume")
touchVar.set("YouTube")
lightVar.set("Empty")
buttonActVar.set('Toggle Brightness')
clickVar.set("Enter")
encoderVar.set("Scroll Windows")
def getRotItem(self):
rotItem = rotVar.get()
if (rotItem == "Volume"):
Function_Dict["rot"] = volume.Set_Volume
elif (rotItem == "Brightness"):
"JUst clicked Brightness"
Function_Dict["rot"] = windows.Change_Brightness
def getTouchItem(self):
touchItem = touchVar.get()
if touchItem == 'YouTube':
Function_Dict['touch'] = youtube.Open_Youtube
elif touchItem == 'Toggle Brightness':
Function_Dict['touch'] = windows.Toggle_Brightness
def getLightItem(self):
lightItem = lightVar.get()
if lightItem == "Auto-Dim":
print("In auto-dim mode....")
Function_Dict['light'] = windows.Auto_Brightness
elif lightItem == "Empty":
Function_Dict['light'] = nothing
def getbuttonActItem(self):
buttonActItem = buttonActVar.get()
if buttonActItem == 'YouTube':
Function_Dict['button'] = youtube.Open_Youtube
elif buttonActItem == 'Toggle Brightness':
Function_Dict['button'] = windows.Toggle_Brightness
def getClickItem(self):
clickItem = clickVar.get()
if clickItem == 'Enter':
Function_Dict['click'] = keyboard.Enter
elif clickItem == 'New Tab':
Function_Dict['click'] = youtube.Open_New_Tab
elif clickItem == 'Close Tab':
Function_Dict['click'] = keyboard.Ctrl_W
def getEncoderItem(self):
encoderItem = encoderVar.get()
if encoderItem == 'Scroll Windows':
Function_Dict['encoder'] = keyboard.Scroll_Windows
elif encoderItem == 'Scroll Tabs':
Function_Dict['encoder'] = keyboard.Scroll_Tabs
def sendData(data):
print("send data")
Label(tk, text="Rot:").grid(column=0,row=0)
Label(tk, text="Touch:").grid(column=0,row=1)
Label(tk, text="Light:").grid(column=0,row=2)
Label(tk, text="Button:").grid(column=0,row=3)
Label(tk, text="Encoder:").grid(column=0,row=4)
Label(tk, text="Encoder Click:").grid(column=0,row=5)
rot = OptionMenu(tk, rotVar, "Volume", "Brightness", command=getRotItem)
rot.config(width=16)
rot.grid(column=1,row=0)
touch = OptionMenu(tk, touchVar, "YouTube", "Toggle Brightness", command=getTouchItem)
touch.config(width=16)
touch.grid(column=1,row=1)
light = OptionMenu(tk, lightVar, "Auto-Dim", command=getLightItem)
light.config(width=16)
light.grid(column=1,row=2)
buttonAct = OptionMenu(tk, buttonActVar, "Toggle Brightness", "YouTube", command=getbuttonActItem)
buttonAct.config(width=16)
buttonAct.grid(column=1,row=3)
click = OptionMenu(tk, clickVar, "Enter", "New Tab", "Close Tab", command=getClickItem)
click.config(width=16)
click.grid(column=1,row=4)
encoder = OptionMenu(tk, encoderVar, "Scroll Windows", "Scroll Tabs", command=getEncoderItem)
encoder.config(width=16)
encoder.grid(column=1,row=5)
button = Button(tk, text="OK", command=getRotItem)
while True:
tk.update_idletasks()
tk.update()
def Call_Function(string):
split_string = string.split(":")
deviceName = split_string[0]
arg = int(split_string[1])
print('device: {}, arg: {}'.format(deviceName, arg))
if deviceName in Function_Dict:
print("Found device in the function dictionary")
try:
Function_Dict[deviceName](arg)
except Exception as e:
print(e)
else:
print('{} not in dict'.format(deviceName))
def Parse_String_From_Board(string):
if "rot" in string:
turnVal = round(int(string[4:])/1023*100)
#windows.Adjust_Brightness(turnVal)
volume.Set_Volume(turnVal)
elif "button" in string:
if "1" in string:
windows.Open_Chrome()
elif "encoder" in string:
if "0" in string:
keyboard.Alt_Tab()
else:
keyboard.Alt_Shift_Tab()
| {"/dragonIO/testAll/GUI.py": ["/Youtube_Control.py"], "/Receive.py": ["/Youtube_Control.py"]} |
50,203 | stevenlandis/SBHACKS_V | refs/heads/master | /dragonIO/pythonDragon/main.py | import mraa
print(mraa.getVersion())
touch = mraa.Gpio(33)
touch.dir(mraa.DIR_IN)
pastTouch = False
while True:
currTouch = touch.read()
if currTouch != pastTouch:
if currTouch:
print('pressed')
else:
print('released')
pastTouch = currTouch
| {"/dragonIO/testAll/GUI.py": ["/Youtube_Control.py"], "/Receive.py": ["/Youtube_Control.py"]} |
50,204 | stevenlandis/SBHACKS_V | refs/heads/master | /main.py | import Volume_Control as volume
import Keyboard_Control as keyboard
def main():
print("Test")
for i in range(10):
keyboard.Sleep_Mode()
print("Done")
if __name__ == "__main__":
main() | {"/dragonIO/testAll/GUI.py": ["/Youtube_Control.py"], "/Receive.py": ["/Youtube_Control.py"]} |
50,205 | stevenlandis/SBHACKS_V | refs/heads/master | /Youtube_Control.py | import webbrowser
import keyword as key
def Open_Youtube(arg):
if arg == 0:
return
try:
chrome_path = 'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe %s'
url = "http://youtube.com/"
# os.startfile(chrome_path)
webbrowser.get(chrome_path).open(url)
except Exception as e:
print(e)
def Open_New_Tab(arg):
if arg == 0:
return
try:
chrome_path = 'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe %s'
url = "https://google.com/"
# os.startfile(chrome_path)
webbrowser.get(chrome_path).open(url)
except Exception as e:
print(e)
def Open_Spotify():
from spotify_local import SpotifyLocal
with SpotifyLocal() as s:
pass | {"/dragonIO/testAll/GUI.py": ["/Youtube_Control.py"], "/Receive.py": ["/Youtube_Control.py"]} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.