repo
stringlengths
7
55
path
stringlengths
4
127
func_name
stringlengths
1
88
original_string
stringlengths
75
19.8k
language
stringclasses
1 value
code
stringlengths
75
19.8k
code_tokens
sequence
docstring
stringlengths
3
17.3k
docstring_tokens
sequence
sha
stringlengths
40
40
url
stringlengths
87
242
partition
stringclasses
1 value
pyviz/param
param/__init__.py
ObjectSelector._validate
def _validate(self, val): """ val must be None or one of the objects in self.objects. """ if not self.check_on_set: self._ensure_value_is_in_objects(val) return if not (val in self.objects or (self.allow_None and val is None)): # CEBALERT: can be called before __init__ has called # super's __init__, i.e. before attrib_name has been set. try: attrib_name = self.name except AttributeError: attrib_name = "" items = [] limiter = ']' length = 0 for item in self.objects: string = str(item) length += len(string) if length < 200: items.append(string) else: limiter = ', ...]' break items = '[' + ', '.join(items) + limiter raise ValueError("%s not in Parameter %s's list of possible objects, " "valid options include %s"%(val,attrib_name, items))
python
def _validate(self, val): """ val must be None or one of the objects in self.objects. """ if not self.check_on_set: self._ensure_value_is_in_objects(val) return if not (val in self.objects or (self.allow_None and val is None)): # CEBALERT: can be called before __init__ has called # super's __init__, i.e. before attrib_name has been set. try: attrib_name = self.name except AttributeError: attrib_name = "" items = [] limiter = ']' length = 0 for item in self.objects: string = str(item) length += len(string) if length < 200: items.append(string) else: limiter = ', ...]' break items = '[' + ', '.join(items) + limiter raise ValueError("%s not in Parameter %s's list of possible objects, " "valid options include %s"%(val,attrib_name, items))
[ "def", "_validate", "(", "self", ",", "val", ")", ":", "if", "not", "self", ".", "check_on_set", ":", "self", ".", "_ensure_value_is_in_objects", "(", "val", ")", "return", "if", "not", "(", "val", "in", "self", ".", "objects", "or", "(", "self", ".", "allow_None", "and", "val", "is", "None", ")", ")", ":", "# CEBALERT: can be called before __init__ has called", "# super's __init__, i.e. before attrib_name has been set.", "try", ":", "attrib_name", "=", "self", ".", "name", "except", "AttributeError", ":", "attrib_name", "=", "\"\"", "items", "=", "[", "]", "limiter", "=", "']'", "length", "=", "0", "for", "item", "in", "self", ".", "objects", ":", "string", "=", "str", "(", "item", ")", "length", "+=", "len", "(", "string", ")", "if", "length", "<", "200", ":", "items", ".", "append", "(", "string", ")", "else", ":", "limiter", "=", "', ...]'", "break", "items", "=", "'['", "+", "', '", ".", "join", "(", "items", ")", "+", "limiter", "raise", "ValueError", "(", "\"%s not in Parameter %s's list of possible objects, \"", "\"valid options include %s\"", "%", "(", "val", ",", "attrib_name", ",", "items", ")", ")" ]
val must be None or one of the objects in self.objects.
[ "val", "must", "be", "None", "or", "one", "of", "the", "objects", "in", "self", ".", "objects", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/__init__.py#L1206-L1235
train
pyviz/param
param/__init__.py
ObjectSelector._ensure_value_is_in_objects
def _ensure_value_is_in_objects(self,val): """ Make sure that the provided value is present on the objects list. Subclasses can override if they support multiple items on a list, to check each item instead. """ if not (val in self.objects): self.objects.append(val)
python
def _ensure_value_is_in_objects(self,val): """ Make sure that the provided value is present on the objects list. Subclasses can override if they support multiple items on a list, to check each item instead. """ if not (val in self.objects): self.objects.append(val)
[ "def", "_ensure_value_is_in_objects", "(", "self", ",", "val", ")", ":", "if", "not", "(", "val", "in", "self", ".", "objects", ")", ":", "self", ".", "objects", ".", "append", "(", "val", ")" ]
Make sure that the provided value is present on the objects list. Subclasses can override if they support multiple items on a list, to check each item instead.
[ "Make", "sure", "that", "the", "provided", "value", "is", "present", "on", "the", "objects", "list", ".", "Subclasses", "can", "override", "if", "they", "support", "multiple", "items", "on", "a", "list", "to", "check", "each", "item", "instead", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/__init__.py#L1237-L1244
train
pyviz/param
param/__init__.py
ClassSelector._validate
def _validate(self,val): """val must be None, an instance of self.class_ if self.is_instance=True or a subclass of self_class if self.is_instance=False""" if isinstance(self.class_, tuple): class_name = ('(%s)' % ', '.join(cl.__name__ for cl in self.class_)) else: class_name = self.class_.__name__ if self.is_instance: if not (isinstance(val,self.class_)) and not (val is None and self.allow_None): raise ValueError( "Parameter '%s' value must be an instance of %s, not '%s'" % (self.name, class_name, val)) else: if not (val is None and self.allow_None) and not (issubclass(val,self.class_)): raise ValueError( "Parameter '%s' must be a subclass of %s, not '%s'" % (val.__name__, class_name, val.__class__.__name__))
python
def _validate(self,val): """val must be None, an instance of self.class_ if self.is_instance=True or a subclass of self_class if self.is_instance=False""" if isinstance(self.class_, tuple): class_name = ('(%s)' % ', '.join(cl.__name__ for cl in self.class_)) else: class_name = self.class_.__name__ if self.is_instance: if not (isinstance(val,self.class_)) and not (val is None and self.allow_None): raise ValueError( "Parameter '%s' value must be an instance of %s, not '%s'" % (self.name, class_name, val)) else: if not (val is None and self.allow_None) and not (issubclass(val,self.class_)): raise ValueError( "Parameter '%s' must be a subclass of %s, not '%s'" % (val.__name__, class_name, val.__class__.__name__))
[ "def", "_validate", "(", "self", ",", "val", ")", ":", "if", "isinstance", "(", "self", ".", "class_", ",", "tuple", ")", ":", "class_name", "=", "(", "'(%s)'", "%", "', '", ".", "join", "(", "cl", ".", "__name__", "for", "cl", "in", "self", ".", "class_", ")", ")", "else", ":", "class_name", "=", "self", ".", "class_", ".", "__name__", "if", "self", ".", "is_instance", ":", "if", "not", "(", "isinstance", "(", "val", ",", "self", ".", "class_", ")", ")", "and", "not", "(", "val", "is", "None", "and", "self", ".", "allow_None", ")", ":", "raise", "ValueError", "(", "\"Parameter '%s' value must be an instance of %s, not '%s'\"", "%", "(", "self", ".", "name", ",", "class_name", ",", "val", ")", ")", "else", ":", "if", "not", "(", "val", "is", "None", "and", "self", ".", "allow_None", ")", "and", "not", "(", "issubclass", "(", "val", ",", "self", ".", "class_", ")", ")", ":", "raise", "ValueError", "(", "\"Parameter '%s' must be a subclass of %s, not '%s'\"", "%", "(", "val", ".", "__name__", ",", "class_name", ",", "val", ".", "__class__", ".", "__name__", ")", ")" ]
val must be None, an instance of self.class_ if self.is_instance=True or a subclass of self_class if self.is_instance=False
[ "val", "must", "be", "None", "an", "instance", "of", "self", ".", "class_", "if", "self", ".", "is_instance", "=", "True", "or", "a", "subclass", "of", "self_class", "if", "self", ".", "is_instance", "=", "False" ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/__init__.py#L1303-L1318
train
pyviz/param
param/__init__.py
ClassSelector.get_range
def get_range(self): """ Return the possible types for this parameter's value. (I.e. return {name: <class>} for all classes that are concrete_descendents() of self.class_.) Only classes from modules that have been imported are added (see concrete_descendents()). """ classes = concrete_descendents(self.class_) d=OrderedDict((name,class_) for name,class_ in classes.items()) if self.allow_None: d['None']=None return d
python
def get_range(self): """ Return the possible types for this parameter's value. (I.e. return {name: <class>} for all classes that are concrete_descendents() of self.class_.) Only classes from modules that have been imported are added (see concrete_descendents()). """ classes = concrete_descendents(self.class_) d=OrderedDict((name,class_) for name,class_ in classes.items()) if self.allow_None: d['None']=None return d
[ "def", "get_range", "(", "self", ")", ":", "classes", "=", "concrete_descendents", "(", "self", ".", "class_", ")", "d", "=", "OrderedDict", "(", "(", "name", ",", "class_", ")", "for", "name", ",", "class_", "in", "classes", ".", "items", "(", ")", ")", "if", "self", ".", "allow_None", ":", "d", "[", "'None'", "]", "=", "None", "return", "d" ]
Return the possible types for this parameter's value. (I.e. return {name: <class>} for all classes that are concrete_descendents() of self.class_.) Only classes from modules that have been imported are added (see concrete_descendents()).
[ "Return", "the", "possible", "types", "for", "this", "parameter", "s", "value", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/__init__.py#L1321-L1335
train
pyviz/param
param/__init__.py
List._validate
def _validate(self, val): """ Checks that the list is of the right length and has the right contents. Otherwise, an exception is raised. """ if self.allow_None and val is None: return if not isinstance(val, list): raise ValueError("List '%s' must be a list."%(self.name)) if self.bounds is not None: min_length,max_length = self.bounds l=len(val) if min_length is not None and max_length is not None: if not (min_length <= l <= max_length): raise ValueError("%s: list length must be between %s and %s (inclusive)"%(self.name,min_length,max_length)) elif min_length is not None: if not min_length <= l: raise ValueError("%s: list length must be at least %s."%(self.name,min_length)) elif max_length is not None: if not l <= max_length: raise ValueError("%s: list length must be at most %s."%(self.name,max_length)) self._check_type(val)
python
def _validate(self, val): """ Checks that the list is of the right length and has the right contents. Otherwise, an exception is raised. """ if self.allow_None and val is None: return if not isinstance(val, list): raise ValueError("List '%s' must be a list."%(self.name)) if self.bounds is not None: min_length,max_length = self.bounds l=len(val) if min_length is not None and max_length is not None: if not (min_length <= l <= max_length): raise ValueError("%s: list length must be between %s and %s (inclusive)"%(self.name,min_length,max_length)) elif min_length is not None: if not min_length <= l: raise ValueError("%s: list length must be at least %s."%(self.name,min_length)) elif max_length is not None: if not l <= max_length: raise ValueError("%s: list length must be at most %s."%(self.name,max_length)) self._check_type(val)
[ "def", "_validate", "(", "self", ",", "val", ")", ":", "if", "self", ".", "allow_None", "and", "val", "is", "None", ":", "return", "if", "not", "isinstance", "(", "val", ",", "list", ")", ":", "raise", "ValueError", "(", "\"List '%s' must be a list.\"", "%", "(", "self", ".", "name", ")", ")", "if", "self", ".", "bounds", "is", "not", "None", ":", "min_length", ",", "max_length", "=", "self", ".", "bounds", "l", "=", "len", "(", "val", ")", "if", "min_length", "is", "not", "None", "and", "max_length", "is", "not", "None", ":", "if", "not", "(", "min_length", "<=", "l", "<=", "max_length", ")", ":", "raise", "ValueError", "(", "\"%s: list length must be between %s and %s (inclusive)\"", "%", "(", "self", ".", "name", ",", "min_length", ",", "max_length", ")", ")", "elif", "min_length", "is", "not", "None", ":", "if", "not", "min_length", "<=", "l", ":", "raise", "ValueError", "(", "\"%s: list length must be at least %s.\"", "%", "(", "self", ".", "name", ",", "min_length", ")", ")", "elif", "max_length", "is", "not", "None", ":", "if", "not", "l", "<=", "max_length", ":", "raise", "ValueError", "(", "\"%s: list length must be at most %s.\"", "%", "(", "self", ".", "name", ",", "max_length", ")", ")", "self", ".", "_check_type", "(", "val", ")" ]
Checks that the list is of the right length and has the right contents. Otherwise, an exception is raised.
[ "Checks", "that", "the", "list", "is", "of", "the", "right", "length", "and", "has", "the", "right", "contents", ".", "Otherwise", "an", "exception", "is", "raised", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/__init__.py#L1357-L1381
train
pyviz/param
param/parameterized.py
logging_level
def logging_level(level): """ Temporarily modify param's logging level. """ level = level.upper() levels = [DEBUG, INFO, WARNING, ERROR, CRITICAL, VERBOSE] level_names = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL', 'VERBOSE'] if level not in level_names: raise Exception("Level %r not in %r" % (level, levels)) param_logger = get_logger() logging_level = param_logger.getEffectiveLevel() param_logger.setLevel(levels[level_names.index(level)]) try: yield None finally: param_logger.setLevel(logging_level)
python
def logging_level(level): """ Temporarily modify param's logging level. """ level = level.upper() levels = [DEBUG, INFO, WARNING, ERROR, CRITICAL, VERBOSE] level_names = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL', 'VERBOSE'] if level not in level_names: raise Exception("Level %r not in %r" % (level, levels)) param_logger = get_logger() logging_level = param_logger.getEffectiveLevel() param_logger.setLevel(levels[level_names.index(level)]) try: yield None finally: param_logger.setLevel(logging_level)
[ "def", "logging_level", "(", "level", ")", ":", "level", "=", "level", ".", "upper", "(", ")", "levels", "=", "[", "DEBUG", ",", "INFO", ",", "WARNING", ",", "ERROR", ",", "CRITICAL", ",", "VERBOSE", "]", "level_names", "=", "[", "'DEBUG'", ",", "'INFO'", ",", "'WARNING'", ",", "'ERROR'", ",", "'CRITICAL'", ",", "'VERBOSE'", "]", "if", "level", "not", "in", "level_names", ":", "raise", "Exception", "(", "\"Level %r not in %r\"", "%", "(", "level", ",", "levels", ")", ")", "param_logger", "=", "get_logger", "(", ")", "logging_level", "=", "param_logger", ".", "getEffectiveLevel", "(", ")", "param_logger", ".", "setLevel", "(", "levels", "[", "level_names", ".", "index", "(", "level", ")", "]", ")", "try", ":", "yield", "None", "finally", ":", "param_logger", ".", "setLevel", "(", "logging_level", ")" ]
Temporarily modify param's logging level.
[ "Temporarily", "modify", "param", "s", "logging", "level", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L69-L86
train
pyviz/param
param/parameterized.py
batch_watch
def batch_watch(parameterized, run=True): """ Context manager to batch watcher events on a parameterized object. The context manager will queue any events triggered by setting a parameter on the supplied parameterized object and dispatch them all at once when the context manager exits. If run=False the queued events are not dispatched and should be processed manually. """ BATCH_WATCH = parameterized.param._BATCH_WATCH parameterized.param._BATCH_WATCH = True try: yield finally: parameterized.param._BATCH_WATCH = BATCH_WATCH if run and not BATCH_WATCH: parameterized.param._batch_call_watchers()
python
def batch_watch(parameterized, run=True): """ Context manager to batch watcher events on a parameterized object. The context manager will queue any events triggered by setting a parameter on the supplied parameterized object and dispatch them all at once when the context manager exits. If run=False the queued events are not dispatched and should be processed manually. """ BATCH_WATCH = parameterized.param._BATCH_WATCH parameterized.param._BATCH_WATCH = True try: yield finally: parameterized.param._BATCH_WATCH = BATCH_WATCH if run and not BATCH_WATCH: parameterized.param._batch_call_watchers()
[ "def", "batch_watch", "(", "parameterized", ",", "run", "=", "True", ")", ":", "BATCH_WATCH", "=", "parameterized", ".", "param", ".", "_BATCH_WATCH", "parameterized", ".", "param", ".", "_BATCH_WATCH", "=", "True", "try", ":", "yield", "finally", ":", "parameterized", ".", "param", ".", "_BATCH_WATCH", "=", "BATCH_WATCH", "if", "run", "and", "not", "BATCH_WATCH", ":", "parameterized", ".", "param", ".", "_batch_call_watchers", "(", ")" ]
Context manager to batch watcher events on a parameterized object. The context manager will queue any events triggered by setting a parameter on the supplied parameterized object and dispatch them all at once when the context manager exits. If run=False the queued events are not dispatched and should be processed manually.
[ "Context", "manager", "to", "batch", "watcher", "events", "on", "a", "parameterized", "object", ".", "The", "context", "manager", "will", "queue", "any", "events", "triggered", "by", "setting", "a", "parameter", "on", "the", "supplied", "parameterized", "object", "and", "dispatch", "them", "all", "at", "once", "when", "the", "context", "manager", "exits", ".", "If", "run", "=", "False", "the", "queued", "events", "are", "not", "dispatched", "and", "should", "be", "processed", "manually", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L90-L105
train
pyviz/param
param/parameterized.py
get_all_slots
def get_all_slots(class_): """ Return a list of slot names for slots defined in class_ and its superclasses. """ # A subclass's __slots__ attribute does not contain slots defined # in its superclass (the superclass' __slots__ end up as # attributes of the subclass). all_slots = [] parent_param_classes = [c for c in classlist(class_)[1::]] for c in parent_param_classes: if hasattr(c,'__slots__'): all_slots+=c.__slots__ return all_slots
python
def get_all_slots(class_): """ Return a list of slot names for slots defined in class_ and its superclasses. """ # A subclass's __slots__ attribute does not contain slots defined # in its superclass (the superclass' __slots__ end up as # attributes of the subclass). all_slots = [] parent_param_classes = [c for c in classlist(class_)[1::]] for c in parent_param_classes: if hasattr(c,'__slots__'): all_slots+=c.__slots__ return all_slots
[ "def", "get_all_slots", "(", "class_", ")", ":", "# A subclass's __slots__ attribute does not contain slots defined", "# in its superclass (the superclass' __slots__ end up as", "# attributes of the subclass).", "all_slots", "=", "[", "]", "parent_param_classes", "=", "[", "c", "for", "c", "in", "classlist", "(", "class_", ")", "[", "1", ":", ":", "]", "]", "for", "c", "in", "parent_param_classes", ":", "if", "hasattr", "(", "c", ",", "'__slots__'", ")", ":", "all_slots", "+=", "c", ".", "__slots__", "return", "all_slots" ]
Return a list of slot names for slots defined in class_ and its superclasses.
[ "Return", "a", "list", "of", "slot", "names", "for", "slots", "defined", "in", "class_", "and", "its", "superclasses", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L136-L149
train
pyviz/param
param/parameterized.py
get_occupied_slots
def get_occupied_slots(instance): """ Return a list of slots for which values have been set. (While a slot might be defined, if a value for that slot hasn't been set, then it's an AttributeError to request the slot's value.) """ return [slot for slot in get_all_slots(type(instance)) if hasattr(instance,slot)]
python
def get_occupied_slots(instance): """ Return a list of slots for which values have been set. (While a slot might be defined, if a value for that slot hasn't been set, then it's an AttributeError to request the slot's value.) """ return [slot for slot in get_all_slots(type(instance)) if hasattr(instance,slot)]
[ "def", "get_occupied_slots", "(", "instance", ")", ":", "return", "[", "slot", "for", "slot", "in", "get_all_slots", "(", "type", "(", "instance", ")", ")", "if", "hasattr", "(", "instance", ",", "slot", ")", "]" ]
Return a list of slots for which values have been set. (While a slot might be defined, if a value for that slot hasn't been set, then it's an AttributeError to request the slot's value.)
[ "Return", "a", "list", "of", "slots", "for", "which", "values", "have", "been", "set", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L152-L161
train
pyviz/param
param/parameterized.py
all_equal
def all_equal(arg1,arg2): """ Return a single boolean for arg1==arg2, even for numpy arrays using element-wise comparison. Uses all(arg1==arg2) for sequences, and arg1==arg2 otherwise. If both objects have an '_infinitely_iterable' attribute, they are not be zipped together and are compared directly instead. """ if all(hasattr(el, '_infinitely_iterable') for el in [arg1,arg2]): return arg1==arg2 try: return all(a1 == a2 for a1, a2 in zip(arg1, arg2)) except TypeError: return arg1==arg2
python
def all_equal(arg1,arg2): """ Return a single boolean for arg1==arg2, even for numpy arrays using element-wise comparison. Uses all(arg1==arg2) for sequences, and arg1==arg2 otherwise. If both objects have an '_infinitely_iterable' attribute, they are not be zipped together and are compared directly instead. """ if all(hasattr(el, '_infinitely_iterable') for el in [arg1,arg2]): return arg1==arg2 try: return all(a1 == a2 for a1, a2 in zip(arg1, arg2)) except TypeError: return arg1==arg2
[ "def", "all_equal", "(", "arg1", ",", "arg2", ")", ":", "if", "all", "(", "hasattr", "(", "el", ",", "'_infinitely_iterable'", ")", "for", "el", "in", "[", "arg1", ",", "arg2", "]", ")", ":", "return", "arg1", "==", "arg2", "try", ":", "return", "all", "(", "a1", "==", "a2", "for", "a1", ",", "a2", "in", "zip", "(", "arg1", ",", "arg2", ")", ")", "except", "TypeError", ":", "return", "arg1", "==", "arg2" ]
Return a single boolean for arg1==arg2, even for numpy arrays using element-wise comparison. Uses all(arg1==arg2) for sequences, and arg1==arg2 otherwise. If both objects have an '_infinitely_iterable' attribute, they are not be zipped together and are compared directly instead.
[ "Return", "a", "single", "boolean", "for", "arg1", "==", "arg2", "even", "for", "numpy", "arrays", "using", "element", "-", "wise", "comparison", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L164-L179
train
pyviz/param
param/parameterized.py
output
def output(func, *output, **kw): """ output allows annotating a method on a Parameterized class to declare that it returns an output of a specific type. The outputs of a Parameterized class can be queried using the Parameterized.param.outputs method. By default the output will inherit the method name but a custom name can be declared by expressing the Parameter type using a keyword argument. Declaring multiple return types using keywords is only supported in Python >= 3.6. The simplest declaration simply declares the method returns an object without any type guarantees, e.g.: @output() If a specific parameter type is specified this is a declaration that the method will return a value of that type, e.g.: @output(param.Number()) To override the default name of the output the type may be declared as a keyword argument, e.g.: @output(custom_name=param.Number()) Multiple outputs may be declared using keywords mapping from output name to the type for Python >= 3.6 or using tuples of the same format, which is supported for earlier versions, i.e. these two declarations are equivalent: @output(number=param.Number(), string=param.String()) @output(('number', param.Number()), ('string', param.String())) output also accepts Python object types which will be upgraded to a ClassSelector, e.g.: @output(int) """ if output: outputs = [] for i, out in enumerate(output): i = i if len(output) > 1 else None if isinstance(out, tuple) and len(out) == 2 and isinstance(out[0], str): outputs.append(out+(i,)) elif isinstance(out, str): outputs.append((out, Parameter(), i)) else: outputs.append((None, out, i)) elif kw: py_major = sys.version_info.major py_minor = sys.version_info.minor if (py_major < 3 or (py_major == 3 and py_minor < 6)) and len(kw) > 1: raise ValueError('Multiple output declaration using keywords ' 'only supported in Python >= 3.6.') # (requires keywords to be kept ordered, which was not true in previous versions) outputs = [(name, otype, i if len(kw) > 1 else None) for i, (name, otype) in enumerate(kw.items())] else: outputs = [(None, Parameter(), None)] names, processed = [], [] for name, otype, i in outputs: if isinstance(otype, type): if issubclass(otype, Parameter): otype = otype() else: from .import ClassSelector otype = ClassSelector(class_=otype) elif isinstance(otype, tuple) and all(isinstance(t, type) for t in otype): from .import ClassSelector otype = ClassSelector(class_=otype) if not isinstance(otype, Parameter): raise ValueError('output type must be declared with a Parameter class, ' 'instance or a Python object type.') processed.append((name, otype, i)) names.append(name) if len(set(names)) != len(names): raise ValueError('When declaring multiple outputs each value ' 'must be unique.') _dinfo = getattr(func, '_dinfo', {}) _dinfo.update({'outputs': processed}) @wraps(func) def _output(*args,**kw): return func(*args,**kw) _output._dinfo = _dinfo return _output
python
def output(func, *output, **kw): """ output allows annotating a method on a Parameterized class to declare that it returns an output of a specific type. The outputs of a Parameterized class can be queried using the Parameterized.param.outputs method. By default the output will inherit the method name but a custom name can be declared by expressing the Parameter type using a keyword argument. Declaring multiple return types using keywords is only supported in Python >= 3.6. The simplest declaration simply declares the method returns an object without any type guarantees, e.g.: @output() If a specific parameter type is specified this is a declaration that the method will return a value of that type, e.g.: @output(param.Number()) To override the default name of the output the type may be declared as a keyword argument, e.g.: @output(custom_name=param.Number()) Multiple outputs may be declared using keywords mapping from output name to the type for Python >= 3.6 or using tuples of the same format, which is supported for earlier versions, i.e. these two declarations are equivalent: @output(number=param.Number(), string=param.String()) @output(('number', param.Number()), ('string', param.String())) output also accepts Python object types which will be upgraded to a ClassSelector, e.g.: @output(int) """ if output: outputs = [] for i, out in enumerate(output): i = i if len(output) > 1 else None if isinstance(out, tuple) and len(out) == 2 and isinstance(out[0], str): outputs.append(out+(i,)) elif isinstance(out, str): outputs.append((out, Parameter(), i)) else: outputs.append((None, out, i)) elif kw: py_major = sys.version_info.major py_minor = sys.version_info.minor if (py_major < 3 or (py_major == 3 and py_minor < 6)) and len(kw) > 1: raise ValueError('Multiple output declaration using keywords ' 'only supported in Python >= 3.6.') # (requires keywords to be kept ordered, which was not true in previous versions) outputs = [(name, otype, i if len(kw) > 1 else None) for i, (name, otype) in enumerate(kw.items())] else: outputs = [(None, Parameter(), None)] names, processed = [], [] for name, otype, i in outputs: if isinstance(otype, type): if issubclass(otype, Parameter): otype = otype() else: from .import ClassSelector otype = ClassSelector(class_=otype) elif isinstance(otype, tuple) and all(isinstance(t, type) for t in otype): from .import ClassSelector otype = ClassSelector(class_=otype) if not isinstance(otype, Parameter): raise ValueError('output type must be declared with a Parameter class, ' 'instance or a Python object type.') processed.append((name, otype, i)) names.append(name) if len(set(names)) != len(names): raise ValueError('When declaring multiple outputs each value ' 'must be unique.') _dinfo = getattr(func, '_dinfo', {}) _dinfo.update({'outputs': processed}) @wraps(func) def _output(*args,**kw): return func(*args,**kw) _output._dinfo = _dinfo return _output
[ "def", "output", "(", "func", ",", "*", "output", ",", "*", "*", "kw", ")", ":", "if", "output", ":", "outputs", "=", "[", "]", "for", "i", ",", "out", "in", "enumerate", "(", "output", ")", ":", "i", "=", "i", "if", "len", "(", "output", ")", ">", "1", "else", "None", "if", "isinstance", "(", "out", ",", "tuple", ")", "and", "len", "(", "out", ")", "==", "2", "and", "isinstance", "(", "out", "[", "0", "]", ",", "str", ")", ":", "outputs", ".", "append", "(", "out", "+", "(", "i", ",", ")", ")", "elif", "isinstance", "(", "out", ",", "str", ")", ":", "outputs", ".", "append", "(", "(", "out", ",", "Parameter", "(", ")", ",", "i", ")", ")", "else", ":", "outputs", ".", "append", "(", "(", "None", ",", "out", ",", "i", ")", ")", "elif", "kw", ":", "py_major", "=", "sys", ".", "version_info", ".", "major", "py_minor", "=", "sys", ".", "version_info", ".", "minor", "if", "(", "py_major", "<", "3", "or", "(", "py_major", "==", "3", "and", "py_minor", "<", "6", ")", ")", "and", "len", "(", "kw", ")", ">", "1", ":", "raise", "ValueError", "(", "'Multiple output declaration using keywords '", "'only supported in Python >= 3.6.'", ")", "# (requires keywords to be kept ordered, which was not true in previous versions)", "outputs", "=", "[", "(", "name", ",", "otype", ",", "i", "if", "len", "(", "kw", ")", ">", "1", "else", "None", ")", "for", "i", ",", "(", "name", ",", "otype", ")", "in", "enumerate", "(", "kw", ".", "items", "(", ")", ")", "]", "else", ":", "outputs", "=", "[", "(", "None", ",", "Parameter", "(", ")", ",", "None", ")", "]", "names", ",", "processed", "=", "[", "]", ",", "[", "]", "for", "name", ",", "otype", ",", "i", "in", "outputs", ":", "if", "isinstance", "(", "otype", ",", "type", ")", ":", "if", "issubclass", "(", "otype", ",", "Parameter", ")", ":", "otype", "=", "otype", "(", ")", "else", ":", "from", ".", "import", "ClassSelector", "otype", "=", "ClassSelector", "(", "class_", "=", "otype", ")", "elif", "isinstance", "(", "otype", ",", "tuple", ")", "and", "all", "(", "isinstance", "(", "t", ",", "type", ")", "for", "t", "in", "otype", ")", ":", "from", ".", "import", "ClassSelector", "otype", "=", "ClassSelector", "(", "class_", "=", "otype", ")", "if", "not", "isinstance", "(", "otype", ",", "Parameter", ")", ":", "raise", "ValueError", "(", "'output type must be declared with a Parameter class, '", "'instance or a Python object type.'", ")", "processed", ".", "append", "(", "(", "name", ",", "otype", ",", "i", ")", ")", "names", ".", "append", "(", "name", ")", "if", "len", "(", "set", "(", "names", ")", ")", "!=", "len", "(", "names", ")", ":", "raise", "ValueError", "(", "'When declaring multiple outputs each value '", "'must be unique.'", ")", "_dinfo", "=", "getattr", "(", "func", ",", "'_dinfo'", ",", "{", "}", ")", "_dinfo", ".", "update", "(", "{", "'outputs'", ":", "processed", "}", ")", "@", "wraps", "(", "func", ")", "def", "_output", "(", "*", "args", ",", "*", "*", "kw", ")", ":", "return", "func", "(", "*", "args", ",", "*", "*", "kw", ")", "_output", ".", "_dinfo", "=", "_dinfo", "return", "_output" ]
output allows annotating a method on a Parameterized class to declare that it returns an output of a specific type. The outputs of a Parameterized class can be queried using the Parameterized.param.outputs method. By default the output will inherit the method name but a custom name can be declared by expressing the Parameter type using a keyword argument. Declaring multiple return types using keywords is only supported in Python >= 3.6. The simplest declaration simply declares the method returns an object without any type guarantees, e.g.: @output() If a specific parameter type is specified this is a declaration that the method will return a value of that type, e.g.: @output(param.Number()) To override the default name of the output the type may be declared as a keyword argument, e.g.: @output(custom_name=param.Number()) Multiple outputs may be declared using keywords mapping from output name to the type for Python >= 3.6 or using tuples of the same format, which is supported for earlier versions, i.e. these two declarations are equivalent: @output(number=param.Number(), string=param.String()) @output(('number', param.Number()), ('string', param.String())) output also accepts Python object types which will be upgraded to a ClassSelector, e.g.: @output(int)
[ "output", "allows", "annotating", "a", "method", "on", "a", "Parameterized", "class", "to", "declare", "that", "it", "returns", "an", "output", "of", "a", "specific", "type", ".", "The", "outputs", "of", "a", "Parameterized", "class", "can", "be", "queried", "using", "the", "Parameterized", ".", "param", ".", "outputs", "method", ".", "By", "default", "the", "output", "will", "inherit", "the", "method", "name", "but", "a", "custom", "name", "can", "be", "declared", "by", "expressing", "the", "Parameter", "type", "using", "a", "keyword", "argument", ".", "Declaring", "multiple", "return", "types", "using", "keywords", "is", "only", "supported", "in", "Python", ">", "=", "3", ".", "6", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L293-L384
train
pyviz/param
param/parameterized.py
Parameters._setup_params
def _setup_params(self_,**params): """ Initialize default and keyword parameter values. First, ensures that all Parameters with 'instantiate=True' (typically used for mutable Parameters) are copied directly into each object, to ensure that there is an independent copy (to avoid suprising aliasing errors). Then sets each of the keyword arguments, warning when any of them are not defined as parameters. Constant Parameters can be set during calls to this method. """ self = self_.param.self ## Deepcopy all 'instantiate=True' parameters # (build a set of names first to avoid redundantly instantiating # a later-overridden parent class's parameter) params_to_instantiate = {} for class_ in classlist(type(self)): if not issubclass(class_, Parameterized): continue for (k,v) in class_.__dict__.items(): # (avoid replacing name with the default of None) if isinstance(v,Parameter) and v.instantiate and k!="name": params_to_instantiate[k]=v for p in params_to_instantiate.values(): self.param._instantiate_param(p) ## keyword arg setting for name,val in params.items(): desc = self.__class__.get_param_descriptor(name)[0] # pylint: disable-msg=E1101 if not desc: self.param.warning("Setting non-parameter attribute %s=%s using a mechanism intended only for parameters",name,val) # i.e. if not desc it's setting an attribute in __dict__, not a Parameter setattr(self,name,val)
python
def _setup_params(self_,**params): """ Initialize default and keyword parameter values. First, ensures that all Parameters with 'instantiate=True' (typically used for mutable Parameters) are copied directly into each object, to ensure that there is an independent copy (to avoid suprising aliasing errors). Then sets each of the keyword arguments, warning when any of them are not defined as parameters. Constant Parameters can be set during calls to this method. """ self = self_.param.self ## Deepcopy all 'instantiate=True' parameters # (build a set of names first to avoid redundantly instantiating # a later-overridden parent class's parameter) params_to_instantiate = {} for class_ in classlist(type(self)): if not issubclass(class_, Parameterized): continue for (k,v) in class_.__dict__.items(): # (avoid replacing name with the default of None) if isinstance(v,Parameter) and v.instantiate and k!="name": params_to_instantiate[k]=v for p in params_to_instantiate.values(): self.param._instantiate_param(p) ## keyword arg setting for name,val in params.items(): desc = self.__class__.get_param_descriptor(name)[0] # pylint: disable-msg=E1101 if not desc: self.param.warning("Setting non-parameter attribute %s=%s using a mechanism intended only for parameters",name,val) # i.e. if not desc it's setting an attribute in __dict__, not a Parameter setattr(self,name,val)
[ "def", "_setup_params", "(", "self_", ",", "*", "*", "params", ")", ":", "self", "=", "self_", ".", "param", ".", "self", "## Deepcopy all 'instantiate=True' parameters", "# (build a set of names first to avoid redundantly instantiating", "# a later-overridden parent class's parameter)", "params_to_instantiate", "=", "{", "}", "for", "class_", "in", "classlist", "(", "type", "(", "self", ")", ")", ":", "if", "not", "issubclass", "(", "class_", ",", "Parameterized", ")", ":", "continue", "for", "(", "k", ",", "v", ")", "in", "class_", ".", "__dict__", ".", "items", "(", ")", ":", "# (avoid replacing name with the default of None)", "if", "isinstance", "(", "v", ",", "Parameter", ")", "and", "v", ".", "instantiate", "and", "k", "!=", "\"name\"", ":", "params_to_instantiate", "[", "k", "]", "=", "v", "for", "p", "in", "params_to_instantiate", ".", "values", "(", ")", ":", "self", ".", "param", ".", "_instantiate_param", "(", "p", ")", "## keyword arg setting", "for", "name", ",", "val", "in", "params", ".", "items", "(", ")", ":", "desc", "=", "self", ".", "__class__", ".", "get_param_descriptor", "(", "name", ")", "[", "0", "]", "# pylint: disable-msg=E1101", "if", "not", "desc", ":", "self", ".", "param", ".", "warning", "(", "\"Setting non-parameter attribute %s=%s using a mechanism intended only for parameters\"", ",", "name", ",", "val", ")", "# i.e. if not desc it's setting an attribute in __dict__, not a Parameter", "setattr", "(", "self", ",", "name", ",", "val", ")" ]
Initialize default and keyword parameter values. First, ensures that all Parameters with 'instantiate=True' (typically used for mutable Parameters) are copied directly into each object, to ensure that there is an independent copy (to avoid suprising aliasing errors). Then sets each of the keyword arguments, warning when any of them are not defined as parameters. Constant Parameters can be set during calls to this method.
[ "Initialize", "default", "and", "keyword", "parameter", "values", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1094-L1129
train
pyviz/param
param/parameterized.py
Parameters.deprecate
def deprecate(cls, fn): """ Decorator to issue warnings for API moving onto the param namespace and to add a docstring directing people to the appropriate method. """ def inner(*args, **kwargs): if cls._disable_stubs: raise AssertionError('Stubs supporting old API disabled') elif cls._disable_stubs is None: pass elif cls._disable_stubs is False: get_logger(name=args[0].__class__.__name__).log( WARNING, 'Use method %r via param namespace ' % fn.__name__) return fn(*args, **kwargs) inner.__doc__= "Inspect .param.%s method for the full docstring" % fn.__name__ return inner
python
def deprecate(cls, fn): """ Decorator to issue warnings for API moving onto the param namespace and to add a docstring directing people to the appropriate method. """ def inner(*args, **kwargs): if cls._disable_stubs: raise AssertionError('Stubs supporting old API disabled') elif cls._disable_stubs is None: pass elif cls._disable_stubs is False: get_logger(name=args[0].__class__.__name__).log( WARNING, 'Use method %r via param namespace ' % fn.__name__) return fn(*args, **kwargs) inner.__doc__= "Inspect .param.%s method for the full docstring" % fn.__name__ return inner
[ "def", "deprecate", "(", "cls", ",", "fn", ")", ":", "def", "inner", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "if", "cls", ".", "_disable_stubs", ":", "raise", "AssertionError", "(", "'Stubs supporting old API disabled'", ")", "elif", "cls", ".", "_disable_stubs", "is", "None", ":", "pass", "elif", "cls", ".", "_disable_stubs", "is", "False", ":", "get_logger", "(", "name", "=", "args", "[", "0", "]", ".", "__class__", ".", "__name__", ")", ".", "log", "(", "WARNING", ",", "'Use method %r via param namespace '", "%", "fn", ".", "__name__", ")", "return", "fn", "(", "*", "args", ",", "*", "*", "kwargs", ")", "inner", ".", "__doc__", "=", "\"Inspect .param.%s method for the full docstring\"", "%", "fn", ".", "__name__", "return", "inner" ]
Decorator to issue warnings for API moving onto the param namespace and to add a docstring directing people to the appropriate method.
[ "Decorator", "to", "issue", "warnings", "for", "API", "moving", "onto", "the", "param", "namespace", "and", "to", "add", "a", "docstring", "directing", "people", "to", "the", "appropriate", "method", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1132-L1149
train
pyviz/param
param/parameterized.py
Parameters.print_param_defaults
def print_param_defaults(self_): """Print the default values of all cls's Parameters.""" cls = self_.cls for key,val in cls.__dict__.items(): if isinstance(val,Parameter): print(cls.__name__+'.'+key+ '='+ repr(val.default))
python
def print_param_defaults(self_): """Print the default values of all cls's Parameters.""" cls = self_.cls for key,val in cls.__dict__.items(): if isinstance(val,Parameter): print(cls.__name__+'.'+key+ '='+ repr(val.default))
[ "def", "print_param_defaults", "(", "self_", ")", ":", "cls", "=", "self_", ".", "cls", "for", "key", ",", "val", "in", "cls", ".", "__dict__", ".", "items", "(", ")", ":", "if", "isinstance", "(", "val", ",", "Parameter", ")", ":", "print", "(", "cls", ".", "__name__", "+", "'.'", "+", "key", "+", "'='", "+", "repr", "(", "val", ".", "default", ")", ")" ]
Print the default values of all cls's Parameters.
[ "Print", "the", "default", "values", "of", "all", "cls", "s", "Parameters", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1188-L1193
train
pyviz/param
param/parameterized.py
Parameters.set_default
def set_default(self_,param_name,value): """ Set the default value of param_name. Equivalent to setting param_name on the class. """ cls = self_.cls setattr(cls,param_name,value)
python
def set_default(self_,param_name,value): """ Set the default value of param_name. Equivalent to setting param_name on the class. """ cls = self_.cls setattr(cls,param_name,value)
[ "def", "set_default", "(", "self_", ",", "param_name", ",", "value", ")", ":", "cls", "=", "self_", ".", "cls", "setattr", "(", "cls", ",", "param_name", ",", "value", ")" ]
Set the default value of param_name. Equivalent to setting param_name on the class.
[ "Set", "the", "default", "value", "of", "param_name", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1196-L1203
train
pyviz/param
param/parameterized.py
Parameters._add_parameter
def _add_parameter(self_, param_name,param_obj): """ Add a new Parameter object into this object's class. Supposed to result in a Parameter equivalent to one declared in the class's source code. """ # CEBALERT: can't we just do # setattr(cls,param_name,param_obj)? The metaclass's # __setattr__ is actually written to handle that. (Would also # need to do something about the params() cache. That cache # is a pain, but it definitely improved the startup time; it # would be worthwhile making sure no method except for one # "add_param()" method has to deal with it (plus any future # remove_param() method.) cls = self_.cls type.__setattr__(cls,param_name,param_obj) ParameterizedMetaclass._initialize_parameter(cls,param_name,param_obj) # delete cached params() try: delattr(cls,'_%s__params'%cls.__name__) except AttributeError: pass
python
def _add_parameter(self_, param_name,param_obj): """ Add a new Parameter object into this object's class. Supposed to result in a Parameter equivalent to one declared in the class's source code. """ # CEBALERT: can't we just do # setattr(cls,param_name,param_obj)? The metaclass's # __setattr__ is actually written to handle that. (Would also # need to do something about the params() cache. That cache # is a pain, but it definitely improved the startup time; it # would be worthwhile making sure no method except for one # "add_param()" method has to deal with it (plus any future # remove_param() method.) cls = self_.cls type.__setattr__(cls,param_name,param_obj) ParameterizedMetaclass._initialize_parameter(cls,param_name,param_obj) # delete cached params() try: delattr(cls,'_%s__params'%cls.__name__) except AttributeError: pass
[ "def", "_add_parameter", "(", "self_", ",", "param_name", ",", "param_obj", ")", ":", "# CEBALERT: can't we just do", "# setattr(cls,param_name,param_obj)? The metaclass's", "# __setattr__ is actually written to handle that. (Would also", "# need to do something about the params() cache. That cache", "# is a pain, but it definitely improved the startup time; it", "# would be worthwhile making sure no method except for one", "# \"add_param()\" method has to deal with it (plus any future", "# remove_param() method.)", "cls", "=", "self_", ".", "cls", "type", ".", "__setattr__", "(", "cls", ",", "param_name", ",", "param_obj", ")", "ParameterizedMetaclass", ".", "_initialize_parameter", "(", "cls", ",", "param_name", ",", "param_obj", ")", "# delete cached params()", "try", ":", "delattr", "(", "cls", ",", "'_%s__params'", "%", "cls", ".", "__name__", ")", "except", "AttributeError", ":", "pass" ]
Add a new Parameter object into this object's class. Supposed to result in a Parameter equivalent to one declared in the class's source code.
[ "Add", "a", "new", "Parameter", "object", "into", "this", "object", "s", "class", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1206-L1228
train
pyviz/param
param/parameterized.py
Parameters.set_param
def set_param(self_, *args,**kwargs): """ For each param=value keyword argument, sets the corresponding parameter of this object or class to the given value. For backwards compatibility, also accepts set_param("param",value) for a single parameter value using positional arguments, but the keyword interface is preferred because it is more compact and can set multiple values. """ BATCH_WATCH = self_.self_or_cls.param._BATCH_WATCH self_.self_or_cls.param._BATCH_WATCH = True self_or_cls = self_.self_or_cls if args: if len(args) == 2 and not args[0] in kwargs and not kwargs: kwargs[args[0]] = args[1] else: self_.self_or_cls.param._BATCH_WATCH = False raise ValueError("Invalid positional arguments for %s.set_param" % (self_or_cls.name)) for (k, v) in kwargs.items(): if k not in self_or_cls.param: self_.self_or_cls.param._BATCH_WATCH = False raise ValueError("'%s' is not a parameter of %s" % (k, self_or_cls.name)) try: setattr(self_or_cls, k, v) except: self_.self_or_cls.param._BATCH_WATCH = False raise self_.self_or_cls.param._BATCH_WATCH = BATCH_WATCH if not BATCH_WATCH: self_._batch_call_watchers()
python
def set_param(self_, *args,**kwargs): """ For each param=value keyword argument, sets the corresponding parameter of this object or class to the given value. For backwards compatibility, also accepts set_param("param",value) for a single parameter value using positional arguments, but the keyword interface is preferred because it is more compact and can set multiple values. """ BATCH_WATCH = self_.self_or_cls.param._BATCH_WATCH self_.self_or_cls.param._BATCH_WATCH = True self_or_cls = self_.self_or_cls if args: if len(args) == 2 and not args[0] in kwargs and not kwargs: kwargs[args[0]] = args[1] else: self_.self_or_cls.param._BATCH_WATCH = False raise ValueError("Invalid positional arguments for %s.set_param" % (self_or_cls.name)) for (k, v) in kwargs.items(): if k not in self_or_cls.param: self_.self_or_cls.param._BATCH_WATCH = False raise ValueError("'%s' is not a parameter of %s" % (k, self_or_cls.name)) try: setattr(self_or_cls, k, v) except: self_.self_or_cls.param._BATCH_WATCH = False raise self_.self_or_cls.param._BATCH_WATCH = BATCH_WATCH if not BATCH_WATCH: self_._batch_call_watchers()
[ "def", "set_param", "(", "self_", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "BATCH_WATCH", "=", "self_", ".", "self_or_cls", ".", "param", ".", "_BATCH_WATCH", "self_", ".", "self_or_cls", ".", "param", ".", "_BATCH_WATCH", "=", "True", "self_or_cls", "=", "self_", ".", "self_or_cls", "if", "args", ":", "if", "len", "(", "args", ")", "==", "2", "and", "not", "args", "[", "0", "]", "in", "kwargs", "and", "not", "kwargs", ":", "kwargs", "[", "args", "[", "0", "]", "]", "=", "args", "[", "1", "]", "else", ":", "self_", ".", "self_or_cls", ".", "param", ".", "_BATCH_WATCH", "=", "False", "raise", "ValueError", "(", "\"Invalid positional arguments for %s.set_param\"", "%", "(", "self_or_cls", ".", "name", ")", ")", "for", "(", "k", ",", "v", ")", "in", "kwargs", ".", "items", "(", ")", ":", "if", "k", "not", "in", "self_or_cls", ".", "param", ":", "self_", ".", "self_or_cls", ".", "param", ".", "_BATCH_WATCH", "=", "False", "raise", "ValueError", "(", "\"'%s' is not a parameter of %s\"", "%", "(", "k", ",", "self_or_cls", ".", "name", ")", ")", "try", ":", "setattr", "(", "self_or_cls", ",", "k", ",", "v", ")", "except", ":", "self_", ".", "self_or_cls", ".", "param", ".", "_BATCH_WATCH", "=", "False", "raise", "self_", ".", "self_or_cls", ".", "param", ".", "_BATCH_WATCH", "=", "BATCH_WATCH", "if", "not", "BATCH_WATCH", ":", "self_", ".", "_batch_call_watchers", "(", ")" ]
For each param=value keyword argument, sets the corresponding parameter of this object or class to the given value. For backwards compatibility, also accepts set_param("param",value) for a single parameter value using positional arguments, but the keyword interface is preferred because it is more compact and can set multiple values.
[ "For", "each", "param", "=", "value", "keyword", "argument", "sets", "the", "corresponding", "parameter", "of", "this", "object", "or", "class", "to", "the", "given", "value", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1259-L1292
train
pyviz/param
param/parameterized.py
Parameters.objects
def objects(self_, instance=True): """ Returns the Parameters of this instance or class If instance=True and called on a Parameterized instance it will create instance parameters for all Parameters defined on the class. To force class parameters to be returned use instance=False. Since classes avoid creating instance parameters unless necessary you may also request only existing instance parameters to be returned by setting instance='existing'. """ cls = self_.cls # CB: we cache the parameters because this method is called often, # and parameters are rarely added (and cannot be deleted) try: pdict = getattr(cls, '_%s__params' % cls.__name__) except AttributeError: paramdict = {} for class_ in classlist(cls): for name, val in class_.__dict__.items(): if isinstance(val, Parameter): paramdict[name] = val # We only want the cache to be visible to the cls on which # params() is called, so we mangle the name ourselves at # runtime (if we were to mangle it now, it would be # _Parameterized.__params for all classes). setattr(cls, '_%s__params' % cls.__name__, paramdict) pdict = paramdict if instance and self_.self is not None: if instance == 'existing': if self_.self._instance__params: return dict(pdict, **self_.self._instance__params) return pdict else: return {k: self_.self.param[k] for k in pdict} return pdict
python
def objects(self_, instance=True): """ Returns the Parameters of this instance or class If instance=True and called on a Parameterized instance it will create instance parameters for all Parameters defined on the class. To force class parameters to be returned use instance=False. Since classes avoid creating instance parameters unless necessary you may also request only existing instance parameters to be returned by setting instance='existing'. """ cls = self_.cls # CB: we cache the parameters because this method is called often, # and parameters are rarely added (and cannot be deleted) try: pdict = getattr(cls, '_%s__params' % cls.__name__) except AttributeError: paramdict = {} for class_ in classlist(cls): for name, val in class_.__dict__.items(): if isinstance(val, Parameter): paramdict[name] = val # We only want the cache to be visible to the cls on which # params() is called, so we mangle the name ourselves at # runtime (if we were to mangle it now, it would be # _Parameterized.__params for all classes). setattr(cls, '_%s__params' % cls.__name__, paramdict) pdict = paramdict if instance and self_.self is not None: if instance == 'existing': if self_.self._instance__params: return dict(pdict, **self_.self._instance__params) return pdict else: return {k: self_.self.param[k] for k in pdict} return pdict
[ "def", "objects", "(", "self_", ",", "instance", "=", "True", ")", ":", "cls", "=", "self_", ".", "cls", "# CB: we cache the parameters because this method is called often,", "# and parameters are rarely added (and cannot be deleted)", "try", ":", "pdict", "=", "getattr", "(", "cls", ",", "'_%s__params'", "%", "cls", ".", "__name__", ")", "except", "AttributeError", ":", "paramdict", "=", "{", "}", "for", "class_", "in", "classlist", "(", "cls", ")", ":", "for", "name", ",", "val", "in", "class_", ".", "__dict__", ".", "items", "(", ")", ":", "if", "isinstance", "(", "val", ",", "Parameter", ")", ":", "paramdict", "[", "name", "]", "=", "val", "# We only want the cache to be visible to the cls on which", "# params() is called, so we mangle the name ourselves at", "# runtime (if we were to mangle it now, it would be", "# _Parameterized.__params for all classes).", "setattr", "(", "cls", ",", "'_%s__params'", "%", "cls", ".", "__name__", ",", "paramdict", ")", "pdict", "=", "paramdict", "if", "instance", "and", "self_", ".", "self", "is", "not", "None", ":", "if", "instance", "==", "'existing'", ":", "if", "self_", ".", "self", ".", "_instance__params", ":", "return", "dict", "(", "pdict", ",", "*", "*", "self_", ".", "self", ".", "_instance__params", ")", "return", "pdict", "else", ":", "return", "{", "k", ":", "self_", ".", "self", ".", "param", "[", "k", "]", "for", "k", "in", "pdict", "}", "return", "pdict" ]
Returns the Parameters of this instance or class If instance=True and called on a Parameterized instance it will create instance parameters for all Parameters defined on the class. To force class parameters to be returned use instance=False. Since classes avoid creating instance parameters unless necessary you may also request only existing instance parameters to be returned by setting instance='existing'.
[ "Returns", "the", "Parameters", "of", "this", "instance", "or", "class" ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1295-L1333
train
pyviz/param
param/parameterized.py
Parameters.trigger
def trigger(self_, *param_names): """ Trigger watchers for the given set of parameter names. Watchers will be triggered whether or not the parameter values have actually changed. """ events = self_.self_or_cls.param._events watchers = self_.self_or_cls.param._watchers self_.self_or_cls.param._events = [] self_.self_or_cls.param._watchers = [] param_values = dict(self_.get_param_values()) params = {name: param_values[name] for name in param_names} self_.self_or_cls.param._TRIGGER = True self_.set_param(**params) self_.self_or_cls.param._TRIGGER = False self_.self_or_cls.param._events = events self_.self_or_cls.param._watchers = watchers
python
def trigger(self_, *param_names): """ Trigger watchers for the given set of parameter names. Watchers will be triggered whether or not the parameter values have actually changed. """ events = self_.self_or_cls.param._events watchers = self_.self_or_cls.param._watchers self_.self_or_cls.param._events = [] self_.self_or_cls.param._watchers = [] param_values = dict(self_.get_param_values()) params = {name: param_values[name] for name in param_names} self_.self_or_cls.param._TRIGGER = True self_.set_param(**params) self_.self_or_cls.param._TRIGGER = False self_.self_or_cls.param._events = events self_.self_or_cls.param._watchers = watchers
[ "def", "trigger", "(", "self_", ",", "*", "param_names", ")", ":", "events", "=", "self_", ".", "self_or_cls", ".", "param", ".", "_events", "watchers", "=", "self_", ".", "self_or_cls", ".", "param", ".", "_watchers", "self_", ".", "self_or_cls", ".", "param", ".", "_events", "=", "[", "]", "self_", ".", "self_or_cls", ".", "param", ".", "_watchers", "=", "[", "]", "param_values", "=", "dict", "(", "self_", ".", "get_param_values", "(", ")", ")", "params", "=", "{", "name", ":", "param_values", "[", "name", "]", "for", "name", "in", "param_names", "}", "self_", ".", "self_or_cls", ".", "param", ".", "_TRIGGER", "=", "True", "self_", ".", "set_param", "(", "*", "*", "params", ")", "self_", ".", "self_or_cls", ".", "param", ".", "_TRIGGER", "=", "False", "self_", ".", "self_or_cls", ".", "param", ".", "_events", "=", "events", "self_", ".", "self_or_cls", ".", "param", ".", "_watchers", "=", "watchers" ]
Trigger watchers for the given set of parameter names. Watchers will be triggered whether or not the parameter values have actually changed.
[ "Trigger", "watchers", "for", "the", "given", "set", "of", "parameter", "names", ".", "Watchers", "will", "be", "triggered", "whether", "or", "not", "the", "parameter", "values", "have", "actually", "changed", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1336-L1352
train
pyviz/param
param/parameterized.py
Parameters._update_event_type
def _update_event_type(self_, watcher, event, triggered): """ Returns an updated Event object with the type field set appropriately. """ if triggered: event_type = 'triggered' else: event_type = 'changed' if watcher.onlychanged else 'set' return Event(what=event.what, name=event.name, obj=event.obj, cls=event.cls, old=event.old, new=event.new, type=event_type)
python
def _update_event_type(self_, watcher, event, triggered): """ Returns an updated Event object with the type field set appropriately. """ if triggered: event_type = 'triggered' else: event_type = 'changed' if watcher.onlychanged else 'set' return Event(what=event.what, name=event.name, obj=event.obj, cls=event.cls, old=event.old, new=event.new, type=event_type)
[ "def", "_update_event_type", "(", "self_", ",", "watcher", ",", "event", ",", "triggered", ")", ":", "if", "triggered", ":", "event_type", "=", "'triggered'", "else", ":", "event_type", "=", "'changed'", "if", "watcher", ".", "onlychanged", "else", "'set'", "return", "Event", "(", "what", "=", "event", ".", "what", ",", "name", "=", "event", ".", "name", ",", "obj", "=", "event", ".", "obj", ",", "cls", "=", "event", ".", "cls", ",", "old", "=", "event", ".", "old", ",", "new", "=", "event", ".", "new", ",", "type", "=", "event_type", ")" ]
Returns an updated Event object with the type field set appropriately.
[ "Returns", "an", "updated", "Event", "object", "with", "the", "type", "field", "set", "appropriately", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1355-L1364
train
pyviz/param
param/parameterized.py
Parameters._call_watcher
def _call_watcher(self_, watcher, event): """ Invoke the given the watcher appropriately given a Event object. """ if self_.self_or_cls.param._TRIGGER: pass elif watcher.onlychanged and (not self_._changed(event)): return if self_.self_or_cls.param._BATCH_WATCH: self_._events.append(event) if watcher not in self_._watchers: self_._watchers.append(watcher) elif watcher.mode == 'args': with batch_watch(self_.self_or_cls, run=False): watcher.fn(self_._update_event_type(watcher, event, self_.self_or_cls.param._TRIGGER)) else: with batch_watch(self_.self_or_cls, run=False): event = self_._update_event_type(watcher, event, self_.self_or_cls.param._TRIGGER) watcher.fn(**{event.name: event.new})
python
def _call_watcher(self_, watcher, event): """ Invoke the given the watcher appropriately given a Event object. """ if self_.self_or_cls.param._TRIGGER: pass elif watcher.onlychanged and (not self_._changed(event)): return if self_.self_or_cls.param._BATCH_WATCH: self_._events.append(event) if watcher not in self_._watchers: self_._watchers.append(watcher) elif watcher.mode == 'args': with batch_watch(self_.self_or_cls, run=False): watcher.fn(self_._update_event_type(watcher, event, self_.self_or_cls.param._TRIGGER)) else: with batch_watch(self_.self_or_cls, run=False): event = self_._update_event_type(watcher, event, self_.self_or_cls.param._TRIGGER) watcher.fn(**{event.name: event.new})
[ "def", "_call_watcher", "(", "self_", ",", "watcher", ",", "event", ")", ":", "if", "self_", ".", "self_or_cls", ".", "param", ".", "_TRIGGER", ":", "pass", "elif", "watcher", ".", "onlychanged", "and", "(", "not", "self_", ".", "_changed", "(", "event", ")", ")", ":", "return", "if", "self_", ".", "self_or_cls", ".", "param", ".", "_BATCH_WATCH", ":", "self_", ".", "_events", ".", "append", "(", "event", ")", "if", "watcher", "not", "in", "self_", ".", "_watchers", ":", "self_", ".", "_watchers", ".", "append", "(", "watcher", ")", "elif", "watcher", ".", "mode", "==", "'args'", ":", "with", "batch_watch", "(", "self_", ".", "self_or_cls", ",", "run", "=", "False", ")", ":", "watcher", ".", "fn", "(", "self_", ".", "_update_event_type", "(", "watcher", ",", "event", ",", "self_", ".", "self_or_cls", ".", "param", ".", "_TRIGGER", ")", ")", "else", ":", "with", "batch_watch", "(", "self_", ".", "self_or_cls", ",", "run", "=", "False", ")", ":", "event", "=", "self_", ".", "_update_event_type", "(", "watcher", ",", "event", ",", "self_", ".", "self_or_cls", ".", "param", ".", "_TRIGGER", ")", "watcher", ".", "fn", "(", "*", "*", "{", "event", ".", "name", ":", "event", ".", "new", "}", ")" ]
Invoke the given the watcher appropriately given a Event object.
[ "Invoke", "the", "given", "the", "watcher", "appropriately", "given", "a", "Event", "object", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1366-L1385
train
pyviz/param
param/parameterized.py
Parameters._batch_call_watchers
def _batch_call_watchers(self_): """ Batch call a set of watchers based on the parameter value settings in kwargs using the queued Event and watcher objects. """ while self_.self_or_cls.param._events: event_dict = OrderedDict([((event.name, event.what), event) for event in self_.self_or_cls.param._events]) watchers = self_.self_or_cls.param._watchers[:] self_.self_or_cls.param._events = [] self_.self_or_cls.param._watchers = [] for watcher in watchers: events = [self_._update_event_type(watcher, event_dict[(name, watcher.what)], self_.self_or_cls.param._TRIGGER) for name in watcher.parameter_names if (name, watcher.what) in event_dict] with batch_watch(self_.self_or_cls, run=False): if watcher.mode == 'args': watcher.fn(*events) else: watcher.fn(**{c.name:c.new for c in events})
python
def _batch_call_watchers(self_): """ Batch call a set of watchers based on the parameter value settings in kwargs using the queued Event and watcher objects. """ while self_.self_or_cls.param._events: event_dict = OrderedDict([((event.name, event.what), event) for event in self_.self_or_cls.param._events]) watchers = self_.self_or_cls.param._watchers[:] self_.self_or_cls.param._events = [] self_.self_or_cls.param._watchers = [] for watcher in watchers: events = [self_._update_event_type(watcher, event_dict[(name, watcher.what)], self_.self_or_cls.param._TRIGGER) for name in watcher.parameter_names if (name, watcher.what) in event_dict] with batch_watch(self_.self_or_cls, run=False): if watcher.mode == 'args': watcher.fn(*events) else: watcher.fn(**{c.name:c.new for c in events})
[ "def", "_batch_call_watchers", "(", "self_", ")", ":", "while", "self_", ".", "self_or_cls", ".", "param", ".", "_events", ":", "event_dict", "=", "OrderedDict", "(", "[", "(", "(", "event", ".", "name", ",", "event", ".", "what", ")", ",", "event", ")", "for", "event", "in", "self_", ".", "self_or_cls", ".", "param", ".", "_events", "]", ")", "watchers", "=", "self_", ".", "self_or_cls", ".", "param", ".", "_watchers", "[", ":", "]", "self_", ".", "self_or_cls", ".", "param", ".", "_events", "=", "[", "]", "self_", ".", "self_or_cls", ".", "param", ".", "_watchers", "=", "[", "]", "for", "watcher", "in", "watchers", ":", "events", "=", "[", "self_", ".", "_update_event_type", "(", "watcher", ",", "event_dict", "[", "(", "name", ",", "watcher", ".", "what", ")", "]", ",", "self_", ".", "self_or_cls", ".", "param", ".", "_TRIGGER", ")", "for", "name", "in", "watcher", ".", "parameter_names", "if", "(", "name", ",", "watcher", ".", "what", ")", "in", "event_dict", "]", "with", "batch_watch", "(", "self_", ".", "self_or_cls", ",", "run", "=", "False", ")", ":", "if", "watcher", ".", "mode", "==", "'args'", ":", "watcher", ".", "fn", "(", "*", "events", ")", "else", ":", "watcher", ".", "fn", "(", "*", "*", "{", "c", ".", "name", ":", "c", ".", "new", "for", "c", "in", "events", "}", ")" ]
Batch call a set of watchers based on the parameter value settings in kwargs using the queued Event and watcher objects.
[ "Batch", "call", "a", "set", "of", "watchers", "based", "on", "the", "parameter", "value", "settings", "in", "kwargs", "using", "the", "queued", "Event", "and", "watcher", "objects", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1388-L1409
train
pyviz/param
param/parameterized.py
Parameters.set_dynamic_time_fn
def set_dynamic_time_fn(self_,time_fn,sublistattr=None): """ Set time_fn for all Dynamic Parameters of this class or instance object that are currently being dynamically generated. Additionally, sets _Dynamic_time_fn=time_fn on this class or instance object, so that any future changes to Dynamic Parmeters can inherit time_fn (e.g. if a Number is changed from a float to a number generator, the number generator will inherit time_fn). If specified, sublistattr is the name of an attribute of this class or instance that contains an iterable collection of subobjects on which set_dynamic_time_fn should be called. If the attribute sublistattr is present on any of the subobjects, set_dynamic_time_fn() will be called for those, too. """ self_or_cls = self_.self_or_cls self_or_cls._Dynamic_time_fn = time_fn if isinstance(self_or_cls,type): a = (None,self_or_cls) else: a = (self_or_cls,) for n,p in self_or_cls.param.objects('existing').items(): if hasattr(p, '_value_is_dynamic'): if p._value_is_dynamic(*a): g = self_or_cls.param.get_value_generator(n) g._Dynamic_time_fn = time_fn if sublistattr: try: sublist = getattr(self_or_cls,sublistattr) except AttributeError: sublist = [] for obj in sublist: obj.param.set_dynamic_time_fn(time_fn,sublistattr)
python
def set_dynamic_time_fn(self_,time_fn,sublistattr=None): """ Set time_fn for all Dynamic Parameters of this class or instance object that are currently being dynamically generated. Additionally, sets _Dynamic_time_fn=time_fn on this class or instance object, so that any future changes to Dynamic Parmeters can inherit time_fn (e.g. if a Number is changed from a float to a number generator, the number generator will inherit time_fn). If specified, sublistattr is the name of an attribute of this class or instance that contains an iterable collection of subobjects on which set_dynamic_time_fn should be called. If the attribute sublistattr is present on any of the subobjects, set_dynamic_time_fn() will be called for those, too. """ self_or_cls = self_.self_or_cls self_or_cls._Dynamic_time_fn = time_fn if isinstance(self_or_cls,type): a = (None,self_or_cls) else: a = (self_or_cls,) for n,p in self_or_cls.param.objects('existing').items(): if hasattr(p, '_value_is_dynamic'): if p._value_is_dynamic(*a): g = self_or_cls.param.get_value_generator(n) g._Dynamic_time_fn = time_fn if sublistattr: try: sublist = getattr(self_or_cls,sublistattr) except AttributeError: sublist = [] for obj in sublist: obj.param.set_dynamic_time_fn(time_fn,sublistattr)
[ "def", "set_dynamic_time_fn", "(", "self_", ",", "time_fn", ",", "sublistattr", "=", "None", ")", ":", "self_or_cls", "=", "self_", ".", "self_or_cls", "self_or_cls", ".", "_Dynamic_time_fn", "=", "time_fn", "if", "isinstance", "(", "self_or_cls", ",", "type", ")", ":", "a", "=", "(", "None", ",", "self_or_cls", ")", "else", ":", "a", "=", "(", "self_or_cls", ",", ")", "for", "n", ",", "p", "in", "self_or_cls", ".", "param", ".", "objects", "(", "'existing'", ")", ".", "items", "(", ")", ":", "if", "hasattr", "(", "p", ",", "'_value_is_dynamic'", ")", ":", "if", "p", ".", "_value_is_dynamic", "(", "*", "a", ")", ":", "g", "=", "self_or_cls", ".", "param", ".", "get_value_generator", "(", "n", ")", "g", ".", "_Dynamic_time_fn", "=", "time_fn", "if", "sublistattr", ":", "try", ":", "sublist", "=", "getattr", "(", "self_or_cls", ",", "sublistattr", ")", "except", "AttributeError", ":", "sublist", "=", "[", "]", "for", "obj", "in", "sublist", ":", "obj", ".", "param", ".", "set_dynamic_time_fn", "(", "time_fn", ",", "sublistattr", ")" ]
Set time_fn for all Dynamic Parameters of this class or instance object that are currently being dynamically generated. Additionally, sets _Dynamic_time_fn=time_fn on this class or instance object, so that any future changes to Dynamic Parmeters can inherit time_fn (e.g. if a Number is changed from a float to a number generator, the number generator will inherit time_fn). If specified, sublistattr is the name of an attribute of this class or instance that contains an iterable collection of subobjects on which set_dynamic_time_fn should be called. If the attribute sublistattr is present on any of the subobjects, set_dynamic_time_fn() will be called for those, too.
[ "Set", "time_fn", "for", "all", "Dynamic", "Parameters", "of", "this", "class", "or", "instance", "object", "that", "are", "currently", "being", "dynamically", "generated", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1412-L1451
train
pyviz/param
param/parameterized.py
Parameters.get_param_values
def get_param_values(self_,onlychanged=False): """ Return a list of name,value pairs for all Parameters of this object. When called on an instance with onlychanged set to True, will only return values that are not equal to the default value (onlychanged has no effect when called on a class). """ self_or_cls = self_.self_or_cls # CEB: we'd actually like to know whether a value has been # explicitly set on the instance, but I'm not sure that's easy # (would need to distinguish instantiation of default from # user setting of value). vals = [] for name,val in self_or_cls.param.objects('existing').items(): value = self_or_cls.param.get_value_generator(name) # (this is pointless for cls) if not onlychanged or not all_equal(value,val.default): vals.append((name,value)) vals.sort(key=itemgetter(0)) return vals
python
def get_param_values(self_,onlychanged=False): """ Return a list of name,value pairs for all Parameters of this object. When called on an instance with onlychanged set to True, will only return values that are not equal to the default value (onlychanged has no effect when called on a class). """ self_or_cls = self_.self_or_cls # CEB: we'd actually like to know whether a value has been # explicitly set on the instance, but I'm not sure that's easy # (would need to distinguish instantiation of default from # user setting of value). vals = [] for name,val in self_or_cls.param.objects('existing').items(): value = self_or_cls.param.get_value_generator(name) # (this is pointless for cls) if not onlychanged or not all_equal(value,val.default): vals.append((name,value)) vals.sort(key=itemgetter(0)) return vals
[ "def", "get_param_values", "(", "self_", ",", "onlychanged", "=", "False", ")", ":", "self_or_cls", "=", "self_", ".", "self_or_cls", "# CEB: we'd actually like to know whether a value has been", "# explicitly set on the instance, but I'm not sure that's easy", "# (would need to distinguish instantiation of default from", "# user setting of value).", "vals", "=", "[", "]", "for", "name", ",", "val", "in", "self_or_cls", ".", "param", ".", "objects", "(", "'existing'", ")", ".", "items", "(", ")", ":", "value", "=", "self_or_cls", ".", "param", ".", "get_value_generator", "(", "name", ")", "# (this is pointless for cls)", "if", "not", "onlychanged", "or", "not", "all_equal", "(", "value", ",", "val", ".", "default", ")", ":", "vals", ".", "append", "(", "(", "name", ",", "value", ")", ")", "vals", ".", "sort", "(", "key", "=", "itemgetter", "(", "0", ")", ")", "return", "vals" ]
Return a list of name,value pairs for all Parameters of this object. When called on an instance with onlychanged set to True, will only return values that are not equal to the default value (onlychanged has no effect when called on a class).
[ "Return", "a", "list", "of", "name", "value", "pairs", "for", "all", "Parameters", "of", "this", "object", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1453-L1475
train
pyviz/param
param/parameterized.py
Parameters.force_new_dynamic_value
def force_new_dynamic_value(self_, name): # pylint: disable-msg=E0213 """ Force a new value to be generated for the dynamic attribute name, and return it. If name is not dynamic, its current value is returned (i.e. equivalent to getattr(name). """ cls_or_slf = self_.self_or_cls param_obj = cls_or_slf.param.objects('existing').get(name) if not param_obj: return getattr(cls_or_slf, name) cls, slf = None, None if isinstance(cls_or_slf,type): cls = cls_or_slf else: slf = cls_or_slf if not hasattr(param_obj,'_force'): return param_obj.__get__(slf, cls) else: return param_obj._force(slf, cls)
python
def force_new_dynamic_value(self_, name): # pylint: disable-msg=E0213 """ Force a new value to be generated for the dynamic attribute name, and return it. If name is not dynamic, its current value is returned (i.e. equivalent to getattr(name). """ cls_or_slf = self_.self_or_cls param_obj = cls_or_slf.param.objects('existing').get(name) if not param_obj: return getattr(cls_or_slf, name) cls, slf = None, None if isinstance(cls_or_slf,type): cls = cls_or_slf else: slf = cls_or_slf if not hasattr(param_obj,'_force'): return param_obj.__get__(slf, cls) else: return param_obj._force(slf, cls)
[ "def", "force_new_dynamic_value", "(", "self_", ",", "name", ")", ":", "# pylint: disable-msg=E0213", "cls_or_slf", "=", "self_", ".", "self_or_cls", "param_obj", "=", "cls_or_slf", ".", "param", ".", "objects", "(", "'existing'", ")", ".", "get", "(", "name", ")", "if", "not", "param_obj", ":", "return", "getattr", "(", "cls_or_slf", ",", "name", ")", "cls", ",", "slf", "=", "None", ",", "None", "if", "isinstance", "(", "cls_or_slf", ",", "type", ")", ":", "cls", "=", "cls_or_slf", "else", ":", "slf", "=", "cls_or_slf", "if", "not", "hasattr", "(", "param_obj", ",", "'_force'", ")", ":", "return", "param_obj", ".", "__get__", "(", "slf", ",", "cls", ")", "else", ":", "return", "param_obj", ".", "_force", "(", "slf", ",", "cls", ")" ]
Force a new value to be generated for the dynamic attribute name, and return it. If name is not dynamic, its current value is returned (i.e. equivalent to getattr(name).
[ "Force", "a", "new", "value", "to", "be", "generated", "for", "the", "dynamic", "attribute", "name", "and", "return", "it", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1478-L1501
train
pyviz/param
param/parameterized.py
Parameters.get_value_generator
def get_value_generator(self_,name): # pylint: disable-msg=E0213 """ Return the value or value-generating object of the named attribute. For most parameters, this is simply the parameter's value (i.e. the same as getattr()), but Dynamic parameters have their value-generating object returned. """ cls_or_slf = self_.self_or_cls param_obj = cls_or_slf.param.objects('existing').get(name) if not param_obj: value = getattr(cls_or_slf,name) # CompositeParameter detected by being a Parameter and having 'attribs' elif hasattr(param_obj,'attribs'): value = [cls_or_slf.param.get_value_generator(a) for a in param_obj.attribs] # not a Dynamic Parameter elif not hasattr(param_obj,'_value_is_dynamic'): value = getattr(cls_or_slf,name) # Dynamic Parameter... else: internal_name = "_%s_param_value"%name if hasattr(cls_or_slf,internal_name): # dealing with object and it's been set on this object value = getattr(cls_or_slf,internal_name) else: # dealing with class or isn't set on the object value = param_obj.default return value
python
def get_value_generator(self_,name): # pylint: disable-msg=E0213 """ Return the value or value-generating object of the named attribute. For most parameters, this is simply the parameter's value (i.e. the same as getattr()), but Dynamic parameters have their value-generating object returned. """ cls_or_slf = self_.self_or_cls param_obj = cls_or_slf.param.objects('existing').get(name) if not param_obj: value = getattr(cls_or_slf,name) # CompositeParameter detected by being a Parameter and having 'attribs' elif hasattr(param_obj,'attribs'): value = [cls_or_slf.param.get_value_generator(a) for a in param_obj.attribs] # not a Dynamic Parameter elif not hasattr(param_obj,'_value_is_dynamic'): value = getattr(cls_or_slf,name) # Dynamic Parameter... else: internal_name = "_%s_param_value"%name if hasattr(cls_or_slf,internal_name): # dealing with object and it's been set on this object value = getattr(cls_or_slf,internal_name) else: # dealing with class or isn't set on the object value = param_obj.default return value
[ "def", "get_value_generator", "(", "self_", ",", "name", ")", ":", "# pylint: disable-msg=E0213", "cls_or_slf", "=", "self_", ".", "self_or_cls", "param_obj", "=", "cls_or_slf", ".", "param", ".", "objects", "(", "'existing'", ")", ".", "get", "(", "name", ")", "if", "not", "param_obj", ":", "value", "=", "getattr", "(", "cls_or_slf", ",", "name", ")", "# CompositeParameter detected by being a Parameter and having 'attribs'", "elif", "hasattr", "(", "param_obj", ",", "'attribs'", ")", ":", "value", "=", "[", "cls_or_slf", ".", "param", ".", "get_value_generator", "(", "a", ")", "for", "a", "in", "param_obj", ".", "attribs", "]", "# not a Dynamic Parameter", "elif", "not", "hasattr", "(", "param_obj", ",", "'_value_is_dynamic'", ")", ":", "value", "=", "getattr", "(", "cls_or_slf", ",", "name", ")", "# Dynamic Parameter...", "else", ":", "internal_name", "=", "\"_%s_param_value\"", "%", "name", "if", "hasattr", "(", "cls_or_slf", ",", "internal_name", ")", ":", "# dealing with object and it's been set on this object", "value", "=", "getattr", "(", "cls_or_slf", ",", "internal_name", ")", "else", ":", "# dealing with class or isn't set on the object", "value", "=", "param_obj", ".", "default", "return", "value" ]
Return the value or value-generating object of the named attribute. For most parameters, this is simply the parameter's value (i.e. the same as getattr()), but Dynamic parameters have their value-generating object returned.
[ "Return", "the", "value", "or", "value", "-", "generating", "object", "of", "the", "named", "attribute", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1504-L1537
train
pyviz/param
param/parameterized.py
Parameters.inspect_value
def inspect_value(self_,name): # pylint: disable-msg=E0213 """ Return the current value of the named attribute without modifying it. Same as getattr() except for Dynamic parameters, which have their last generated value returned. """ cls_or_slf = self_.self_or_cls param_obj = cls_or_slf.param.objects('existing').get(name) if not param_obj: value = getattr(cls_or_slf,name) elif hasattr(param_obj,'attribs'): value = [cls_or_slf.param.inspect_value(a) for a in param_obj.attribs] elif not hasattr(param_obj,'_inspect'): value = getattr(cls_or_slf,name) else: if isinstance(cls_or_slf,type): value = param_obj._inspect(None,cls_or_slf) else: value = param_obj._inspect(cls_or_slf,None) return value
python
def inspect_value(self_,name): # pylint: disable-msg=E0213 """ Return the current value of the named attribute without modifying it. Same as getattr() except for Dynamic parameters, which have their last generated value returned. """ cls_or_slf = self_.self_or_cls param_obj = cls_or_slf.param.objects('existing').get(name) if not param_obj: value = getattr(cls_or_slf,name) elif hasattr(param_obj,'attribs'): value = [cls_or_slf.param.inspect_value(a) for a in param_obj.attribs] elif not hasattr(param_obj,'_inspect'): value = getattr(cls_or_slf,name) else: if isinstance(cls_or_slf,type): value = param_obj._inspect(None,cls_or_slf) else: value = param_obj._inspect(cls_or_slf,None) return value
[ "def", "inspect_value", "(", "self_", ",", "name", ")", ":", "# pylint: disable-msg=E0213", "cls_or_slf", "=", "self_", ".", "self_or_cls", "param_obj", "=", "cls_or_slf", ".", "param", ".", "objects", "(", "'existing'", ")", ".", "get", "(", "name", ")", "if", "not", "param_obj", ":", "value", "=", "getattr", "(", "cls_or_slf", ",", "name", ")", "elif", "hasattr", "(", "param_obj", ",", "'attribs'", ")", ":", "value", "=", "[", "cls_or_slf", ".", "param", ".", "inspect_value", "(", "a", ")", "for", "a", "in", "param_obj", ".", "attribs", "]", "elif", "not", "hasattr", "(", "param_obj", ",", "'_inspect'", ")", ":", "value", "=", "getattr", "(", "cls_or_slf", ",", "name", ")", "else", ":", "if", "isinstance", "(", "cls_or_slf", ",", "type", ")", ":", "value", "=", "param_obj", ".", "_inspect", "(", "None", ",", "cls_or_slf", ")", "else", ":", "value", "=", "param_obj", ".", "_inspect", "(", "cls_or_slf", ",", "None", ")", "return", "value" ]
Return the current value of the named attribute without modifying it. Same as getattr() except for Dynamic parameters, which have their last generated value returned.
[ "Return", "the", "current", "value", "of", "the", "named", "attribute", "without", "modifying", "it", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1539-L1561
train
pyviz/param
param/parameterized.py
Parameters.outputs
def outputs(self_): """ Returns a mapping between any declared outputs and a tuple of the declared Parameter type, the output method, and the index into the output if multiple outputs are returned. """ outputs = {} for cls in classlist(self_.cls): for name in dir(cls): method = getattr(self_.self_or_cls, name) dinfo = getattr(method, '_dinfo', {}) if 'outputs' not in dinfo: continue for override, otype, idx in dinfo['outputs']: if override is not None: name = override outputs[name] = (otype, method, idx) return outputs
python
def outputs(self_): """ Returns a mapping between any declared outputs and a tuple of the declared Parameter type, the output method, and the index into the output if multiple outputs are returned. """ outputs = {} for cls in classlist(self_.cls): for name in dir(cls): method = getattr(self_.self_or_cls, name) dinfo = getattr(method, '_dinfo', {}) if 'outputs' not in dinfo: continue for override, otype, idx in dinfo['outputs']: if override is not None: name = override outputs[name] = (otype, method, idx) return outputs
[ "def", "outputs", "(", "self_", ")", ":", "outputs", "=", "{", "}", "for", "cls", "in", "classlist", "(", "self_", ".", "cls", ")", ":", "for", "name", "in", "dir", "(", "cls", ")", ":", "method", "=", "getattr", "(", "self_", ".", "self_or_cls", ",", "name", ")", "dinfo", "=", "getattr", "(", "method", ",", "'_dinfo'", ",", "{", "}", ")", "if", "'outputs'", "not", "in", "dinfo", ":", "continue", "for", "override", ",", "otype", ",", "idx", "in", "dinfo", "[", "'outputs'", "]", ":", "if", "override", "is", "not", "None", ":", "name", "=", "override", "outputs", "[", "name", "]", "=", "(", "otype", ",", "method", ",", "idx", ")", "return", "outputs" ]
Returns a mapping between any declared outputs and a tuple of the declared Parameter type, the output method, and the index into the output if multiple outputs are returned.
[ "Returns", "a", "mapping", "between", "any", "declared", "outputs", "and", "a", "tuple", "of", "the", "declared", "Parameter", "type", "the", "output", "method", "and", "the", "index", "into", "the", "output", "if", "multiple", "outputs", "are", "returned", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1568-L1585
train
pyviz/param
param/parameterized.py
Parameters.unwatch
def unwatch(self_,watcher): """ Unwatch watchers set either with watch or watch_values. """ try: self_._watch('remove',watcher) except: self_.warning('No such watcher {watcher} to remove.'.format(watcher=watcher))
python
def unwatch(self_,watcher): """ Unwatch watchers set either with watch or watch_values. """ try: self_._watch('remove',watcher) except: self_.warning('No such watcher {watcher} to remove.'.format(watcher=watcher))
[ "def", "unwatch", "(", "self_", ",", "watcher", ")", ":", "try", ":", "self_", ".", "_watch", "(", "'remove'", ",", "watcher", ")", "except", ":", "self_", ".", "warning", "(", "'No such watcher {watcher} to remove.'", ".", "format", "(", "watcher", "=", "watcher", ")", ")" ]
Unwatch watchers set either with watch or watch_values.
[ "Unwatch", "watchers", "set", "either", "with", "watch", "or", "watch_values", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1645-L1652
train
pyviz/param
param/parameterized.py
Parameters.print_param_values
def print_param_values(self_): """Print the values of all this object's Parameters.""" self = self_.self for name,val in self.param.get_param_values(): print('%s.%s = %s' % (self.name,name,val))
python
def print_param_values(self_): """Print the values of all this object's Parameters.""" self = self_.self for name,val in self.param.get_param_values(): print('%s.%s = %s' % (self.name,name,val))
[ "def", "print_param_values", "(", "self_", ")", ":", "self", "=", "self_", ".", "self", "for", "name", ",", "val", "in", "self", ".", "param", ".", "get_param_values", "(", ")", ":", "print", "(", "'%s.%s = %s'", "%", "(", "self", ".", "name", ",", "name", ",", "val", ")", ")" ]
Print the values of all this object's Parameters.
[ "Print", "the", "values", "of", "all", "this", "object", "s", "Parameters", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1706-L1710
train
pyviz/param
param/parameterized.py
Parameters.warning
def warning(self_, msg,*args,**kw): """ Print msg merged with args as a warning, unless module variable warnings_as_exceptions is True, then raise an Exception containing the arguments. See Python's logging module for details of message formatting. """ if not warnings_as_exceptions: global warning_count warning_count+=1 self_.__db_print(WARNING,msg,*args,**kw) else: raise Exception("Warning: " + msg % args)
python
def warning(self_, msg,*args,**kw): """ Print msg merged with args as a warning, unless module variable warnings_as_exceptions is True, then raise an Exception containing the arguments. See Python's logging module for details of message formatting. """ if not warnings_as_exceptions: global warning_count warning_count+=1 self_.__db_print(WARNING,msg,*args,**kw) else: raise Exception("Warning: " + msg % args)
[ "def", "warning", "(", "self_", ",", "msg", ",", "*", "args", ",", "*", "*", "kw", ")", ":", "if", "not", "warnings_as_exceptions", ":", "global", "warning_count", "warning_count", "+=", "1", "self_", ".", "__db_print", "(", "WARNING", ",", "msg", ",", "*", "args", ",", "*", "*", "kw", ")", "else", ":", "raise", "Exception", "(", "\"Warning: \"", "+", "msg", "%", "args", ")" ]
Print msg merged with args as a warning, unless module variable warnings_as_exceptions is True, then raise an Exception containing the arguments. See Python's logging module for details of message formatting.
[ "Print", "msg", "merged", "with", "args", "as", "a", "warning", "unless", "module", "variable", "warnings_as_exceptions", "is", "True", "then", "raise", "an", "Exception", "containing", "the", "arguments", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1712-L1725
train
pyviz/param
param/parameterized.py
Parameters.message
def message(self_,msg,*args,**kw): """ Print msg merged with args as a message. See Python's logging module for details of message formatting. """ self_.__db_print(INFO,msg,*args,**kw)
python
def message(self_,msg,*args,**kw): """ Print msg merged with args as a message. See Python's logging module for details of message formatting. """ self_.__db_print(INFO,msg,*args,**kw)
[ "def", "message", "(", "self_", ",", "msg", ",", "*", "args", ",", "*", "*", "kw", ")", ":", "self_", ".", "__db_print", "(", "INFO", ",", "msg", ",", "*", "args", ",", "*", "*", "kw", ")" ]
Print msg merged with args as a message. See Python's logging module for details of message formatting.
[ "Print", "msg", "merged", "with", "args", "as", "a", "message", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1727-L1733
train
pyviz/param
param/parameterized.py
Parameters.verbose
def verbose(self_,msg,*args,**kw): """ Print msg merged with args as a verbose message. See Python's logging module for details of message formatting. """ self_.__db_print(VERBOSE,msg,*args,**kw)
python
def verbose(self_,msg,*args,**kw): """ Print msg merged with args as a verbose message. See Python's logging module for details of message formatting. """ self_.__db_print(VERBOSE,msg,*args,**kw)
[ "def", "verbose", "(", "self_", ",", "msg", ",", "*", "args", ",", "*", "*", "kw", ")", ":", "self_", ".", "__db_print", "(", "VERBOSE", ",", "msg", ",", "*", "args", ",", "*", "*", "kw", ")" ]
Print msg merged with args as a verbose message. See Python's logging module for details of message formatting.
[ "Print", "msg", "merged", "with", "args", "as", "a", "verbose", "message", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1735-L1741
train
pyviz/param
param/parameterized.py
Parameters.debug
def debug(self_,msg,*args,**kw): """ Print msg merged with args as a debugging statement. See Python's logging module for details of message formatting. """ self_.__db_print(DEBUG,msg,*args,**kw)
python
def debug(self_,msg,*args,**kw): """ Print msg merged with args as a debugging statement. See Python's logging module for details of message formatting. """ self_.__db_print(DEBUG,msg,*args,**kw)
[ "def", "debug", "(", "self_", ",", "msg", ",", "*", "args", ",", "*", "*", "kw", ")", ":", "self_", ".", "__db_print", "(", "DEBUG", ",", "msg", ",", "*", "args", ",", "*", "*", "kw", ")" ]
Print msg merged with args as a debugging statement. See Python's logging module for details of message formatting.
[ "Print", "msg", "merged", "with", "args", "as", "a", "debugging", "statement", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1743-L1749
train
pyviz/param
param/parameterized.py
ParameterizedMetaclass.__class_docstring_signature
def __class_docstring_signature(mcs, max_repr_len=15): """ Autogenerate a keyword signature in the class docstring for all available parameters. This is particularly useful in the IPython Notebook as IPython will parse this signature to allow tab-completion of keywords. max_repr_len: Maximum length (in characters) of value reprs. """ processed_kws, keyword_groups = set(), [] for cls in reversed(mcs.mro()): keyword_group = [] for (k,v) in sorted(cls.__dict__.items()): if isinstance(v, Parameter) and k not in processed_kws: param_type = v.__class__.__name__ keyword_group.append("%s=%s" % (k, param_type)) processed_kws.add(k) keyword_groups.append(keyword_group) keywords = [el for grp in reversed(keyword_groups) for el in grp] class_docstr = "\n"+mcs.__doc__ if mcs.__doc__ else '' signature = "params(%s)" % (", ".join(keywords)) description = param_pager(mcs) if (docstring_describe_params and param_pager) else '' mcs.__doc__ = signature + class_docstr + '\n' + description
python
def __class_docstring_signature(mcs, max_repr_len=15): """ Autogenerate a keyword signature in the class docstring for all available parameters. This is particularly useful in the IPython Notebook as IPython will parse this signature to allow tab-completion of keywords. max_repr_len: Maximum length (in characters) of value reprs. """ processed_kws, keyword_groups = set(), [] for cls in reversed(mcs.mro()): keyword_group = [] for (k,v) in sorted(cls.__dict__.items()): if isinstance(v, Parameter) and k not in processed_kws: param_type = v.__class__.__name__ keyword_group.append("%s=%s" % (k, param_type)) processed_kws.add(k) keyword_groups.append(keyword_group) keywords = [el for grp in reversed(keyword_groups) for el in grp] class_docstr = "\n"+mcs.__doc__ if mcs.__doc__ else '' signature = "params(%s)" % (", ".join(keywords)) description = param_pager(mcs) if (docstring_describe_params and param_pager) else '' mcs.__doc__ = signature + class_docstr + '\n' + description
[ "def", "__class_docstring_signature", "(", "mcs", ",", "max_repr_len", "=", "15", ")", ":", "processed_kws", ",", "keyword_groups", "=", "set", "(", ")", ",", "[", "]", "for", "cls", "in", "reversed", "(", "mcs", ".", "mro", "(", ")", ")", ":", "keyword_group", "=", "[", "]", "for", "(", "k", ",", "v", ")", "in", "sorted", "(", "cls", ".", "__dict__", ".", "items", "(", ")", ")", ":", "if", "isinstance", "(", "v", ",", "Parameter", ")", "and", "k", "not", "in", "processed_kws", ":", "param_type", "=", "v", ".", "__class__", ".", "__name__", "keyword_group", ".", "append", "(", "\"%s=%s\"", "%", "(", "k", ",", "param_type", ")", ")", "processed_kws", ".", "add", "(", "k", ")", "keyword_groups", ".", "append", "(", "keyword_group", ")", "keywords", "=", "[", "el", "for", "grp", "in", "reversed", "(", "keyword_groups", ")", "for", "el", "in", "grp", "]", "class_docstr", "=", "\"\\n\"", "+", "mcs", ".", "__doc__", "if", "mcs", ".", "__doc__", "else", "''", "signature", "=", "\"params(%s)\"", "%", "(", "\", \"", ".", "join", "(", "keywords", ")", ")", "description", "=", "param_pager", "(", "mcs", ")", "if", "(", "docstring_describe_params", "and", "param_pager", ")", "else", "''", "mcs", ".", "__doc__", "=", "signature", "+", "class_docstr", "+", "'\\n'", "+", "description" ]
Autogenerate a keyword signature in the class docstring for all available parameters. This is particularly useful in the IPython Notebook as IPython will parse this signature to allow tab-completion of keywords. max_repr_len: Maximum length (in characters) of value reprs.
[ "Autogenerate", "a", "keyword", "signature", "in", "the", "class", "docstring", "for", "all", "available", "parameters", ".", "This", "is", "particularly", "useful", "in", "the", "IPython", "Notebook", "as", "IPython", "will", "parse", "this", "signature", "to", "allow", "tab", "-", "completion", "of", "keywords", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1830-L1853
train
pyviz/param
param/parameterized.py
ParameterizedMetaclass.__param_inheritance
def __param_inheritance(mcs,param_name,param): """ Look for Parameter values in superclasses of this Parameterized class. Ordinarily, when a Python object is instantiated, attributes not given values in the constructor will inherit the value given in the object's class, or in its superclasses. For Parameters owned by Parameterized classes, we have implemented an additional level of default lookup, should this ordinary lookup return only None. In such a case, i.e. when no non-None value was found for a Parameter by the usual inheritance mechanisms, we explicitly look for Parameters with the same name in superclasses of this Parameterized class, and use the first such value that we find. The goal is to be able to set the default value (or other slots) of a Parameter within a Parameterized class, just as we can set values for non-Parameter objects in Parameterized classes, and have the values inherited through the Parameterized hierarchy as usual. Note that instantiate is handled differently: if there is a parameter with the same name in one of the superclasses with instantiate set to True, this parameter will inherit instatiate=True. """ # get all relevant slots (i.e. slots defined in all # superclasses of this parameter) slots = {} for p_class in classlist(type(param))[1::]: slots.update(dict.fromkeys(p_class.__slots__)) # note for some eventual future: python 3.6+ descriptors grew # __set_name__, which could replace this and _set_names setattr(param,'owner',mcs) del slots['owner'] # backwards compatibility (see Composite parameter) if 'objtype' in slots: setattr(param,'objtype',mcs) del slots['objtype'] # instantiate is handled specially for superclass in classlist(mcs)[::-1]: super_param = superclass.__dict__.get(param_name) if isinstance(super_param, Parameter) and super_param.instantiate is True: param.instantiate=True del slots['instantiate'] for slot in slots.keys(): superclasses = iter(classlist(mcs)[::-1]) # Search up the hierarchy until param.slot (which has to # be obtained using getattr(param,slot)) is not None, or # we run out of classes to search. while getattr(param,slot) is None: try: param_super_class = next(superclasses) except StopIteration: break new_param = param_super_class.__dict__.get(param_name) if new_param is not None and hasattr(new_param,slot): # (slot might not be there because could be a more # general type of Parameter) new_value = getattr(new_param,slot) setattr(param,slot,new_value)
python
def __param_inheritance(mcs,param_name,param): """ Look for Parameter values in superclasses of this Parameterized class. Ordinarily, when a Python object is instantiated, attributes not given values in the constructor will inherit the value given in the object's class, or in its superclasses. For Parameters owned by Parameterized classes, we have implemented an additional level of default lookup, should this ordinary lookup return only None. In such a case, i.e. when no non-None value was found for a Parameter by the usual inheritance mechanisms, we explicitly look for Parameters with the same name in superclasses of this Parameterized class, and use the first such value that we find. The goal is to be able to set the default value (or other slots) of a Parameter within a Parameterized class, just as we can set values for non-Parameter objects in Parameterized classes, and have the values inherited through the Parameterized hierarchy as usual. Note that instantiate is handled differently: if there is a parameter with the same name in one of the superclasses with instantiate set to True, this parameter will inherit instatiate=True. """ # get all relevant slots (i.e. slots defined in all # superclasses of this parameter) slots = {} for p_class in classlist(type(param))[1::]: slots.update(dict.fromkeys(p_class.__slots__)) # note for some eventual future: python 3.6+ descriptors grew # __set_name__, which could replace this and _set_names setattr(param,'owner',mcs) del slots['owner'] # backwards compatibility (see Composite parameter) if 'objtype' in slots: setattr(param,'objtype',mcs) del slots['objtype'] # instantiate is handled specially for superclass in classlist(mcs)[::-1]: super_param = superclass.__dict__.get(param_name) if isinstance(super_param, Parameter) and super_param.instantiate is True: param.instantiate=True del slots['instantiate'] for slot in slots.keys(): superclasses = iter(classlist(mcs)[::-1]) # Search up the hierarchy until param.slot (which has to # be obtained using getattr(param,slot)) is not None, or # we run out of classes to search. while getattr(param,slot) is None: try: param_super_class = next(superclasses) except StopIteration: break new_param = param_super_class.__dict__.get(param_name) if new_param is not None and hasattr(new_param,slot): # (slot might not be there because could be a more # general type of Parameter) new_value = getattr(new_param,slot) setattr(param,slot,new_value)
[ "def", "__param_inheritance", "(", "mcs", ",", "param_name", ",", "param", ")", ":", "# get all relevant slots (i.e. slots defined in all", "# superclasses of this parameter)", "slots", "=", "{", "}", "for", "p_class", "in", "classlist", "(", "type", "(", "param", ")", ")", "[", "1", ":", ":", "]", ":", "slots", ".", "update", "(", "dict", ".", "fromkeys", "(", "p_class", ".", "__slots__", ")", ")", "# note for some eventual future: python 3.6+ descriptors grew", "# __set_name__, which could replace this and _set_names", "setattr", "(", "param", ",", "'owner'", ",", "mcs", ")", "del", "slots", "[", "'owner'", "]", "# backwards compatibility (see Composite parameter)", "if", "'objtype'", "in", "slots", ":", "setattr", "(", "param", ",", "'objtype'", ",", "mcs", ")", "del", "slots", "[", "'objtype'", "]", "# instantiate is handled specially", "for", "superclass", "in", "classlist", "(", "mcs", ")", "[", ":", ":", "-", "1", "]", ":", "super_param", "=", "superclass", ".", "__dict__", ".", "get", "(", "param_name", ")", "if", "isinstance", "(", "super_param", ",", "Parameter", ")", "and", "super_param", ".", "instantiate", "is", "True", ":", "param", ".", "instantiate", "=", "True", "del", "slots", "[", "'instantiate'", "]", "for", "slot", "in", "slots", ".", "keys", "(", ")", ":", "superclasses", "=", "iter", "(", "classlist", "(", "mcs", ")", "[", ":", ":", "-", "1", "]", ")", "# Search up the hierarchy until param.slot (which has to", "# be obtained using getattr(param,slot)) is not None, or", "# we run out of classes to search.", "while", "getattr", "(", "param", ",", "slot", ")", "is", "None", ":", "try", ":", "param_super_class", "=", "next", "(", "superclasses", ")", "except", "StopIteration", ":", "break", "new_param", "=", "param_super_class", ".", "__dict__", ".", "get", "(", "param_name", ")", "if", "new_param", "is", "not", "None", "and", "hasattr", "(", "new_param", ",", "slot", ")", ":", "# (slot might not be there because could be a more", "# general type of Parameter)", "new_value", "=", "getattr", "(", "new_param", ",", "slot", ")", "setattr", "(", "param", ",", "slot", ",", "new_value", ")" ]
Look for Parameter values in superclasses of this Parameterized class. Ordinarily, when a Python object is instantiated, attributes not given values in the constructor will inherit the value given in the object's class, or in its superclasses. For Parameters owned by Parameterized classes, we have implemented an additional level of default lookup, should this ordinary lookup return only None. In such a case, i.e. when no non-None value was found for a Parameter by the usual inheritance mechanisms, we explicitly look for Parameters with the same name in superclasses of this Parameterized class, and use the first such value that we find. The goal is to be able to set the default value (or other slots) of a Parameter within a Parameterized class, just as we can set values for non-Parameter objects in Parameterized classes, and have the values inherited through the Parameterized hierarchy as usual. Note that instantiate is handled differently: if there is a parameter with the same name in one of the superclasses with instantiate set to True, this parameter will inherit instatiate=True.
[ "Look", "for", "Parameter", "values", "in", "superclasses", "of", "this", "Parameterized", "class", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L1940-L2011
train
pyviz/param
param/parameterized.py
ParamOverrides._check_params
def _check_params(self,params): """ Print a warning if params contains something that is not a Parameter of the overridden object. """ overridden_object_params = list(self._overridden.param) for item in params: if item not in overridden_object_params: self.param.warning("'%s' will be ignored (not a Parameter).",item)
python
def _check_params(self,params): """ Print a warning if params contains something that is not a Parameter of the overridden object. """ overridden_object_params = list(self._overridden.param) for item in params: if item not in overridden_object_params: self.param.warning("'%s' will be ignored (not a Parameter).",item)
[ "def", "_check_params", "(", "self", ",", "params", ")", ":", "overridden_object_params", "=", "list", "(", "self", ".", "_overridden", ".", "param", ")", "for", "item", "in", "params", ":", "if", "item", "not", "in", "overridden_object_params", ":", "self", ".", "param", ".", "warning", "(", "\"'%s' will be ignored (not a Parameter).\"", ",", "item", ")" ]
Print a warning if params contains something that is not a Parameter of the overridden object.
[ "Print", "a", "warning", "if", "params", "contains", "something", "that", "is", "not", "a", "Parameter", "of", "the", "overridden", "object", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L2653-L2661
train
pyviz/param
param/parameterized.py
ParamOverrides._extract_extra_keywords
def _extract_extra_keywords(self,params): """ Return any items in params that are not also parameters of the overridden object. """ extra_keywords = {} overridden_object_params = list(self._overridden.param) for name, val in params.items(): if name not in overridden_object_params: extra_keywords[name]=val # CEBALERT: should we remove name from params # (i.e. del params[name]) so that it's only available # via extra_keywords()? return extra_keywords
python
def _extract_extra_keywords(self,params): """ Return any items in params that are not also parameters of the overridden object. """ extra_keywords = {} overridden_object_params = list(self._overridden.param) for name, val in params.items(): if name not in overridden_object_params: extra_keywords[name]=val # CEBALERT: should we remove name from params # (i.e. del params[name]) so that it's only available # via extra_keywords()? return extra_keywords
[ "def", "_extract_extra_keywords", "(", "self", ",", "params", ")", ":", "extra_keywords", "=", "{", "}", "overridden_object_params", "=", "list", "(", "self", ".", "_overridden", ".", "param", ")", "for", "name", ",", "val", "in", "params", ".", "items", "(", ")", ":", "if", "name", "not", "in", "overridden_object_params", ":", "extra_keywords", "[", "name", "]", "=", "val", "# CEBALERT: should we remove name from params", "# (i.e. del params[name]) so that it's only available", "# via extra_keywords()?", "return", "extra_keywords" ]
Return any items in params that are not also parameters of the overridden object.
[ "Return", "any", "items", "in", "params", "that", "are", "not", "also", "parameters", "of", "the", "overridden", "object", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L2663-L2676
train
pyviz/param
param/parameterized.py
ParameterizedFunction.instance
def instance(self_or_cls,**params): """ Return an instance of this class, copying parameters from any existing instance provided. """ if isinstance (self_or_cls,ParameterizedMetaclass): cls = self_or_cls else: p = params params = dict(self_or_cls.get_param_values()) params.update(p) params.pop('name') cls = self_or_cls.__class__ inst=Parameterized.__new__(cls) Parameterized.__init__(inst,**params) if 'name' in params: inst.__name__ = params['name'] else: inst.__name__ = self_or_cls.name return inst
python
def instance(self_or_cls,**params): """ Return an instance of this class, copying parameters from any existing instance provided. """ if isinstance (self_or_cls,ParameterizedMetaclass): cls = self_or_cls else: p = params params = dict(self_or_cls.get_param_values()) params.update(p) params.pop('name') cls = self_or_cls.__class__ inst=Parameterized.__new__(cls) Parameterized.__init__(inst,**params) if 'name' in params: inst.__name__ = params['name'] else: inst.__name__ = self_or_cls.name return inst
[ "def", "instance", "(", "self_or_cls", ",", "*", "*", "params", ")", ":", "if", "isinstance", "(", "self_or_cls", ",", "ParameterizedMetaclass", ")", ":", "cls", "=", "self_or_cls", "else", ":", "p", "=", "params", "params", "=", "dict", "(", "self_or_cls", ".", "get_param_values", "(", ")", ")", "params", ".", "update", "(", "p", ")", "params", ".", "pop", "(", "'name'", ")", "cls", "=", "self_or_cls", ".", "__class__", "inst", "=", "Parameterized", ".", "__new__", "(", "cls", ")", "Parameterized", ".", "__init__", "(", "inst", ",", "*", "*", "params", ")", "if", "'name'", "in", "params", ":", "inst", ".", "__name__", "=", "params", "[", "'name'", "]", "else", ":", "inst", ".", "__name__", "=", "self_or_cls", ".", "name", "return", "inst" ]
Return an instance of this class, copying parameters from any existing instance provided.
[ "Return", "an", "instance", "of", "this", "class", "copying", "parameters", "from", "any", "existing", "instance", "provided", "." ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L2702-L2721
train
pyviz/param
param/parameterized.py
ParameterizedFunction.script_repr
def script_repr(self,imports=[],prefix=" "): """ Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y """ return self.pprint(imports,prefix,unknown_value='',qualify=True, separator="\n")
python
def script_repr(self,imports=[],prefix=" "): """ Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y """ return self.pprint(imports,prefix,unknown_value='',qualify=True, separator="\n")
[ "def", "script_repr", "(", "self", ",", "imports", "=", "[", "]", ",", "prefix", "=", "\" \"", ")", ":", "return", "self", ".", "pprint", "(", "imports", ",", "prefix", ",", "unknown_value", "=", "''", ",", "qualify", "=", "True", ",", "separator", "=", "\"\\n\"", ")" ]
Same as Parameterized.script_repr, except that X.classname(Y is replaced with X.classname.instance(Y
[ "Same", "as", "Parameterized", ".", "script_repr", "except", "that", "X", ".", "classname", "(", "Y", "is", "replaced", "with", "X", ".", "classname", ".", "instance", "(", "Y" ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L2742-L2748
train
pyviz/param
param/parameterized.py
ParameterizedFunction.pprint
def pprint(self, imports=None, prefix="\n ",unknown_value='<?>', qualify=False, separator=""): """ Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y """ r = Parameterized.pprint(self,imports,prefix, unknown_value=unknown_value, qualify=qualify,separator=separator) classname=self.__class__.__name__ return r.replace(".%s("%classname,".%s.instance("%classname)
python
def pprint(self, imports=None, prefix="\n ",unknown_value='<?>', qualify=False, separator=""): """ Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y """ r = Parameterized.pprint(self,imports,prefix, unknown_value=unknown_value, qualify=qualify,separator=separator) classname=self.__class__.__name__ return r.replace(".%s("%classname,".%s.instance("%classname)
[ "def", "pprint", "(", "self", ",", "imports", "=", "None", ",", "prefix", "=", "\"\\n \"", ",", "unknown_value", "=", "'<?>'", ",", "qualify", "=", "False", ",", "separator", "=", "\"\"", ")", ":", "r", "=", "Parameterized", ".", "pprint", "(", "self", ",", "imports", ",", "prefix", ",", "unknown_value", "=", "unknown_value", ",", "qualify", "=", "qualify", ",", "separator", "=", "separator", ")", "classname", "=", "self", ".", "__class__", ".", "__name__", "return", "r", ".", "replace", "(", "\".%s(\"", "%", "classname", ",", "\".%s.instance(\"", "%", "classname", ")" ]
Same as Parameterized.pprint, except that X.classname(Y is replaced with X.classname.instance(Y
[ "Same", "as", "Parameterized", ".", "pprint", "except", "that", "X", ".", "classname", "(", "Y", "is", "replaced", "with", "X", ".", "classname", ".", "instance", "(", "Y" ]
8f0dafa78defa883247b40635f96cc6d5c1b3481
https://github.com/pyviz/param/blob/8f0dafa78defa883247b40635f96cc6d5c1b3481/param/parameterized.py#L2751-L2761
train
sass/libsass-python
sassutils/builder.py
Manifest.resolve_filename
def resolve_filename(self, package_dir, filename): """Gets a proper full relative path of Sass source and CSS source that will be generated, according to ``package_dir`` and ``filename``. :param package_dir: the path of package directory :type package_dir: :class:`str`, :class:`basestring` :param filename: the filename of Sass/SCSS source to compile :type filename: :class:`str`, :class:`basestring` :returns: a pair of (sass, css) path :rtype: :class:`tuple` """ sass_path = os.path.join(package_dir, self.sass_path, filename) if self.strip_extension: filename, _ = os.path.splitext(filename) css_filename = filename + '.css' css_path = os.path.join(package_dir, self.css_path, css_filename) return sass_path, css_path
python
def resolve_filename(self, package_dir, filename): """Gets a proper full relative path of Sass source and CSS source that will be generated, according to ``package_dir`` and ``filename``. :param package_dir: the path of package directory :type package_dir: :class:`str`, :class:`basestring` :param filename: the filename of Sass/SCSS source to compile :type filename: :class:`str`, :class:`basestring` :returns: a pair of (sass, css) path :rtype: :class:`tuple` """ sass_path = os.path.join(package_dir, self.sass_path, filename) if self.strip_extension: filename, _ = os.path.splitext(filename) css_filename = filename + '.css' css_path = os.path.join(package_dir, self.css_path, css_filename) return sass_path, css_path
[ "def", "resolve_filename", "(", "self", ",", "package_dir", ",", "filename", ")", ":", "sass_path", "=", "os", ".", "path", ".", "join", "(", "package_dir", ",", "self", ".", "sass_path", ",", "filename", ")", "if", "self", ".", "strip_extension", ":", "filename", ",", "_", "=", "os", ".", "path", ".", "splitext", "(", "filename", ")", "css_filename", "=", "filename", "+", "'.css'", "css_path", "=", "os", ".", "path", ".", "join", "(", "package_dir", ",", "self", ".", "css_path", ",", "css_filename", ")", "return", "sass_path", ",", "css_path" ]
Gets a proper full relative path of Sass source and CSS source that will be generated, according to ``package_dir`` and ``filename``. :param package_dir: the path of package directory :type package_dir: :class:`str`, :class:`basestring` :param filename: the filename of Sass/SCSS source to compile :type filename: :class:`str`, :class:`basestring` :returns: a pair of (sass, css) path :rtype: :class:`tuple`
[ "Gets", "a", "proper", "full", "relative", "path", "of", "Sass", "source", "and", "CSS", "source", "that", "will", "be", "generated", "according", "to", "package_dir", "and", "filename", "." ]
fde5b18bc761f0253e71685ee5489e4beb8a403e
https://github.com/sass/libsass-python/blob/fde5b18bc761f0253e71685ee5489e4beb8a403e/sassutils/builder.py#L181-L199
train
sass/libsass-python
sassutils/builder.py
Manifest.unresolve_filename
def unresolve_filename(self, package_dir, filename): """Retrieves the probable source path from the output filename. Pass in a .css path to get out a .scss path. :param package_dir: the path of the package directory :type package_dir: :class:`str` :param filename: the css filename :type filename: :class:`str` :returns: the scss filename :rtype: :class:`str` """ filename, _ = os.path.splitext(filename) if self.strip_extension: for ext in ('.scss', '.sass'): test_path = os.path.join( package_dir, self.sass_path, filename + ext, ) if os.path.exists(test_path): return filename + ext else: # file not found, let it error with `.scss` extension return filename + '.scss' else: return filename
python
def unresolve_filename(self, package_dir, filename): """Retrieves the probable source path from the output filename. Pass in a .css path to get out a .scss path. :param package_dir: the path of the package directory :type package_dir: :class:`str` :param filename: the css filename :type filename: :class:`str` :returns: the scss filename :rtype: :class:`str` """ filename, _ = os.path.splitext(filename) if self.strip_extension: for ext in ('.scss', '.sass'): test_path = os.path.join( package_dir, self.sass_path, filename + ext, ) if os.path.exists(test_path): return filename + ext else: # file not found, let it error with `.scss` extension return filename + '.scss' else: return filename
[ "def", "unresolve_filename", "(", "self", ",", "package_dir", ",", "filename", ")", ":", "filename", ",", "_", "=", "os", ".", "path", ".", "splitext", "(", "filename", ")", "if", "self", ".", "strip_extension", ":", "for", "ext", "in", "(", "'.scss'", ",", "'.sass'", ")", ":", "test_path", "=", "os", ".", "path", ".", "join", "(", "package_dir", ",", "self", ".", "sass_path", ",", "filename", "+", "ext", ",", ")", "if", "os", ".", "path", ".", "exists", "(", "test_path", ")", ":", "return", "filename", "+", "ext", "else", ":", "# file not found, let it error with `.scss` extension", "return", "filename", "+", "'.scss'", "else", ":", "return", "filename" ]
Retrieves the probable source path from the output filename. Pass in a .css path to get out a .scss path. :param package_dir: the path of the package directory :type package_dir: :class:`str` :param filename: the css filename :type filename: :class:`str` :returns: the scss filename :rtype: :class:`str`
[ "Retrieves", "the", "probable", "source", "path", "from", "the", "output", "filename", ".", "Pass", "in", "a", ".", "css", "path", "to", "get", "out", "a", ".", "scss", "path", "." ]
fde5b18bc761f0253e71685ee5489e4beb8a403e
https://github.com/sass/libsass-python/blob/fde5b18bc761f0253e71685ee5489e4beb8a403e/sassutils/builder.py#L201-L223
train
sass/libsass-python
sass.py
_validate_importers
def _validate_importers(importers): """Validates the importers and decorates the callables with our output formatter. """ # They could have no importers, that's chill if importers is None: return None def _to_importer(priority, func): assert isinstance(priority, int), priority assert callable(func), func return (priority, _importer_callback_wrapper(func)) # Our code assumes tuple of tuples return tuple(_to_importer(priority, func) for priority, func in importers)
python
def _validate_importers(importers): """Validates the importers and decorates the callables with our output formatter. """ # They could have no importers, that's chill if importers is None: return None def _to_importer(priority, func): assert isinstance(priority, int), priority assert callable(func), func return (priority, _importer_callback_wrapper(func)) # Our code assumes tuple of tuples return tuple(_to_importer(priority, func) for priority, func in importers)
[ "def", "_validate_importers", "(", "importers", ")", ":", "# They could have no importers, that's chill", "if", "importers", "is", "None", ":", "return", "None", "def", "_to_importer", "(", "priority", ",", "func", ")", ":", "assert", "isinstance", "(", "priority", ",", "int", ")", ",", "priority", "assert", "callable", "(", "func", ")", ",", "func", "return", "(", "priority", ",", "_importer_callback_wrapper", "(", "func", ")", ")", "# Our code assumes tuple of tuples", "return", "tuple", "(", "_to_importer", "(", "priority", ",", "func", ")", "for", "priority", ",", "func", "in", "importers", ")" ]
Validates the importers and decorates the callables with our output formatter.
[ "Validates", "the", "importers", "and", "decorates", "the", "callables", "with", "our", "output", "formatter", "." ]
fde5b18bc761f0253e71685ee5489e4beb8a403e
https://github.com/sass/libsass-python/blob/fde5b18bc761f0253e71685ee5489e4beb8a403e/sass.py#L218-L232
train
sass/libsass-python
sass.py
and_join
def and_join(strings): """Join the given ``strings`` by commas with last `' and '` conjuction. >>> and_join(['Korea', 'Japan', 'China', 'Taiwan']) 'Korea, Japan, China, and Taiwan' :param strings: a list of words to join :type string: :class:`collections.abc.Sequence` :returns: a joined string :rtype: :class:`str`, :class:`basestring` """ last = len(strings) - 1 if last == 0: return strings[0] elif last < 0: return '' iterator = enumerate(strings) return ', '.join('and ' + s if i == last else s for i, s in iterator)
python
def and_join(strings): """Join the given ``strings`` by commas with last `' and '` conjuction. >>> and_join(['Korea', 'Japan', 'China', 'Taiwan']) 'Korea, Japan, China, and Taiwan' :param strings: a list of words to join :type string: :class:`collections.abc.Sequence` :returns: a joined string :rtype: :class:`str`, :class:`basestring` """ last = len(strings) - 1 if last == 0: return strings[0] elif last < 0: return '' iterator = enumerate(strings) return ', '.join('and ' + s if i == last else s for i, s in iterator)
[ "def", "and_join", "(", "strings", ")", ":", "last", "=", "len", "(", "strings", ")", "-", "1", "if", "last", "==", "0", ":", "return", "strings", "[", "0", "]", "elif", "last", "<", "0", ":", "return", "''", "iterator", "=", "enumerate", "(", "strings", ")", "return", "', '", ".", "join", "(", "'and '", "+", "s", "if", "i", "==", "last", "else", "s", "for", "i", ",", "s", "in", "iterator", ")" ]
Join the given ``strings`` by commas with last `' and '` conjuction. >>> and_join(['Korea', 'Japan', 'China', 'Taiwan']) 'Korea, Japan, China, and Taiwan' :param strings: a list of words to join :type string: :class:`collections.abc.Sequence` :returns: a joined string :rtype: :class:`str`, :class:`basestring`
[ "Join", "the", "given", "strings", "by", "commas", "with", "last", "and", "conjuction", "." ]
fde5b18bc761f0253e71685ee5489e4beb8a403e
https://github.com/sass/libsass-python/blob/fde5b18bc761f0253e71685ee5489e4beb8a403e/sass.py#L741-L759
train
dbkaplan/dry-rest-permissions
dry_rest_permissions/generics.py
allow_staff_or_superuser
def allow_staff_or_superuser(func): """ This decorator is used to abstract common is_staff and is_superuser functionality out of permission checks. It determines which parameter is the request based on name. """ is_object_permission = "has_object" in func.__name__ @wraps(func) def func_wrapper(*args, **kwargs): request = args[0] # use second parameter if object permission if is_object_permission: request = args[1] if request.user.is_staff or request.user.is_superuser: return True return func(*args, **kwargs) return func_wrapper
python
def allow_staff_or_superuser(func): """ This decorator is used to abstract common is_staff and is_superuser functionality out of permission checks. It determines which parameter is the request based on name. """ is_object_permission = "has_object" in func.__name__ @wraps(func) def func_wrapper(*args, **kwargs): request = args[0] # use second parameter if object permission if is_object_permission: request = args[1] if request.user.is_staff or request.user.is_superuser: return True return func(*args, **kwargs) return func_wrapper
[ "def", "allow_staff_or_superuser", "(", "func", ")", ":", "is_object_permission", "=", "\"has_object\"", "in", "func", ".", "__name__", "@", "wraps", "(", "func", ")", "def", "func_wrapper", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "request", "=", "args", "[", "0", "]", "# use second parameter if object permission", "if", "is_object_permission", ":", "request", "=", "args", "[", "1", "]", "if", "request", ".", "user", ".", "is_staff", "or", "request", ".", "user", ".", "is_superuser", ":", "return", "True", "return", "func", "(", "*", "args", ",", "*", "*", "kwargs", ")", "return", "func_wrapper" ]
This decorator is used to abstract common is_staff and is_superuser functionality out of permission checks. It determines which parameter is the request based on name.
[ "This", "decorator", "is", "used", "to", "abstract", "common", "is_staff", "and", "is_superuser", "functionality", "out", "of", "permission", "checks", ".", "It", "determines", "which", "parameter", "is", "the", "request", "based", "on", "name", "." ]
b2d4d3c76041f6c405e2537bea9639657b75b90e
https://github.com/dbkaplan/dry-rest-permissions/blob/b2d4d3c76041f6c405e2537bea9639657b75b90e/dry_rest_permissions/generics.py#L269-L288
train
dbkaplan/dry-rest-permissions
dry_rest_permissions/generics.py
authenticated_users
def authenticated_users(func): """ This decorator is used to abstract common authentication checking functionality out of permission checks. It determines which parameter is the request based on name. """ is_object_permission = "has_object" in func.__name__ @wraps(func) def func_wrapper(*args, **kwargs): request = args[0] # use second parameter if object permission if is_object_permission: request = args[1] if not(request.user and request.user.is_authenticated): return False return func(*args, **kwargs) return func_wrapper
python
def authenticated_users(func): """ This decorator is used to abstract common authentication checking functionality out of permission checks. It determines which parameter is the request based on name. """ is_object_permission = "has_object" in func.__name__ @wraps(func) def func_wrapper(*args, **kwargs): request = args[0] # use second parameter if object permission if is_object_permission: request = args[1] if not(request.user and request.user.is_authenticated): return False return func(*args, **kwargs) return func_wrapper
[ "def", "authenticated_users", "(", "func", ")", ":", "is_object_permission", "=", "\"has_object\"", "in", "func", ".", "__name__", "@", "wraps", "(", "func", ")", "def", "func_wrapper", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "request", "=", "args", "[", "0", "]", "# use second parameter if object permission", "if", "is_object_permission", ":", "request", "=", "args", "[", "1", "]", "if", "not", "(", "request", ".", "user", "and", "request", ".", "user", ".", "is_authenticated", ")", ":", "return", "False", "return", "func", "(", "*", "args", ",", "*", "*", "kwargs", ")", "return", "func_wrapper" ]
This decorator is used to abstract common authentication checking functionality out of permission checks. It determines which parameter is the request based on name.
[ "This", "decorator", "is", "used", "to", "abstract", "common", "authentication", "checking", "functionality", "out", "of", "permission", "checks", ".", "It", "determines", "which", "parameter", "is", "the", "request", "based", "on", "name", "." ]
b2d4d3c76041f6c405e2537bea9639657b75b90e
https://github.com/dbkaplan/dry-rest-permissions/blob/b2d4d3c76041f6c405e2537bea9639657b75b90e/dry_rest_permissions/generics.py#L291-L310
train
dbkaplan/dry-rest-permissions
dry_rest_permissions/generics.py
DRYPermissionFiltersBase.filter_queryset
def filter_queryset(self, request, queryset, view): """ This method overrides the standard filter_queryset method. This method will check to see if the view calling this is from a list type action. This function will also route the filter by action type if action_routing is set to True. """ # Check if this is a list type request if view.lookup_field not in view.kwargs: if not self.action_routing: return self.filter_list_queryset(request, queryset, view) else: method_name = "filter_{action}_queryset".format(action=view.action) return getattr(self, method_name)(request, queryset, view) return queryset
python
def filter_queryset(self, request, queryset, view): """ This method overrides the standard filter_queryset method. This method will check to see if the view calling this is from a list type action. This function will also route the filter by action type if action_routing is set to True. """ # Check if this is a list type request if view.lookup_field not in view.kwargs: if not self.action_routing: return self.filter_list_queryset(request, queryset, view) else: method_name = "filter_{action}_queryset".format(action=view.action) return getattr(self, method_name)(request, queryset, view) return queryset
[ "def", "filter_queryset", "(", "self", ",", "request", ",", "queryset", ",", "view", ")", ":", "# Check if this is a list type request", "if", "view", ".", "lookup_field", "not", "in", "view", ".", "kwargs", ":", "if", "not", "self", ".", "action_routing", ":", "return", "self", ".", "filter_list_queryset", "(", "request", ",", "queryset", ",", "view", ")", "else", ":", "method_name", "=", "\"filter_{action}_queryset\"", ".", "format", "(", "action", "=", "view", ".", "action", ")", "return", "getattr", "(", "self", ",", "method_name", ")", "(", "request", ",", "queryset", ",", "view", ")", "return", "queryset" ]
This method overrides the standard filter_queryset method. This method will check to see if the view calling this is from a list type action. This function will also route the filter by action type if action_routing is set to True.
[ "This", "method", "overrides", "the", "standard", "filter_queryset", "method", ".", "This", "method", "will", "check", "to", "see", "if", "the", "view", "calling", "this", "is", "from", "a", "list", "type", "action", ".", "This", "function", "will", "also", "route", "the", "filter", "by", "action", "type", "if", "action_routing", "is", "set", "to", "True", "." ]
b2d4d3c76041f6c405e2537bea9639657b75b90e
https://github.com/dbkaplan/dry-rest-permissions/blob/b2d4d3c76041f6c405e2537bea9639657b75b90e/dry_rest_permissions/generics.py#L35-L49
train
dbkaplan/dry-rest-permissions
dry_rest_permissions/generics.py
DRYPermissions.has_permission
def has_permission(self, request, view): """ Overrides the standard function and figures out methods to call for global permissions. """ if not self.global_permissions: return True serializer_class = view.get_serializer_class() assert serializer_class.Meta.model is not None, ( "global_permissions set to true without a model " "set on the serializer for '%s'" % view.__class__.__name__ ) model_class = serializer_class.Meta.model action_method_name = None if hasattr(view, 'action'): action = self._get_action(view.action) action_method_name = "has_{action}_permission".format(action=action) # If the specific action permission exists then use it, otherwise use general. if hasattr(model_class, action_method_name): return getattr(model_class, action_method_name)(request) if request.method in permissions.SAFE_METHODS: assert hasattr(model_class, 'has_read_permission'), \ self._get_error_message(model_class, 'has_read_permission', action_method_name) return model_class.has_read_permission(request) else: assert hasattr(model_class, 'has_write_permission'), \ self._get_error_message(model_class, 'has_write_permission', action_method_name) return model_class.has_write_permission(request)
python
def has_permission(self, request, view): """ Overrides the standard function and figures out methods to call for global permissions. """ if not self.global_permissions: return True serializer_class = view.get_serializer_class() assert serializer_class.Meta.model is not None, ( "global_permissions set to true without a model " "set on the serializer for '%s'" % view.__class__.__name__ ) model_class = serializer_class.Meta.model action_method_name = None if hasattr(view, 'action'): action = self._get_action(view.action) action_method_name = "has_{action}_permission".format(action=action) # If the specific action permission exists then use it, otherwise use general. if hasattr(model_class, action_method_name): return getattr(model_class, action_method_name)(request) if request.method in permissions.SAFE_METHODS: assert hasattr(model_class, 'has_read_permission'), \ self._get_error_message(model_class, 'has_read_permission', action_method_name) return model_class.has_read_permission(request) else: assert hasattr(model_class, 'has_write_permission'), \ self._get_error_message(model_class, 'has_write_permission', action_method_name) return model_class.has_write_permission(request)
[ "def", "has_permission", "(", "self", ",", "request", ",", "view", ")", ":", "if", "not", "self", ".", "global_permissions", ":", "return", "True", "serializer_class", "=", "view", ".", "get_serializer_class", "(", ")", "assert", "serializer_class", ".", "Meta", ".", "model", "is", "not", "None", ",", "(", "\"global_permissions set to true without a model \"", "\"set on the serializer for '%s'\"", "%", "view", ".", "__class__", ".", "__name__", ")", "model_class", "=", "serializer_class", ".", "Meta", ".", "model", "action_method_name", "=", "None", "if", "hasattr", "(", "view", ",", "'action'", ")", ":", "action", "=", "self", ".", "_get_action", "(", "view", ".", "action", ")", "action_method_name", "=", "\"has_{action}_permission\"", ".", "format", "(", "action", "=", "action", ")", "# If the specific action permission exists then use it, otherwise use general.", "if", "hasattr", "(", "model_class", ",", "action_method_name", ")", ":", "return", "getattr", "(", "model_class", ",", "action_method_name", ")", "(", "request", ")", "if", "request", ".", "method", "in", "permissions", ".", "SAFE_METHODS", ":", "assert", "hasattr", "(", "model_class", ",", "'has_read_permission'", ")", ",", "self", ".", "_get_error_message", "(", "model_class", ",", "'has_read_permission'", ",", "action_method_name", ")", "return", "model_class", ".", "has_read_permission", "(", "request", ")", "else", ":", "assert", "hasattr", "(", "model_class", ",", "'has_write_permission'", ")", ",", "self", ".", "_get_error_message", "(", "model_class", ",", "'has_write_permission'", ",", "action_method_name", ")", "return", "model_class", ".", "has_write_permission", "(", "request", ")" ]
Overrides the standard function and figures out methods to call for global permissions.
[ "Overrides", "the", "standard", "function", "and", "figures", "out", "methods", "to", "call", "for", "global", "permissions", "." ]
b2d4d3c76041f6c405e2537bea9639657b75b90e
https://github.com/dbkaplan/dry-rest-permissions/blob/b2d4d3c76041f6c405e2537bea9639657b75b90e/dry_rest_permissions/generics.py#L97-L128
train
dbkaplan/dry-rest-permissions
dry_rest_permissions/generics.py
DRYPermissions.has_object_permission
def has_object_permission(self, request, view, obj): """ Overrides the standard function and figures out methods to call for object permissions. """ if not self.object_permissions: return True serializer_class = view.get_serializer_class() model_class = serializer_class.Meta.model action_method_name = None if hasattr(view, 'action'): action = self._get_action(view.action) action_method_name = "has_object_{action}_permission".format(action=action) # If the specific action permission exists then use it, otherwise use general. if hasattr(obj, action_method_name): return getattr(obj, action_method_name)(request) if request.method in permissions.SAFE_METHODS: assert hasattr(obj, 'has_object_read_permission'), \ self._get_error_message(model_class, 'has_object_read_permission', action_method_name) return obj.has_object_read_permission(request) else: assert hasattr(obj, 'has_object_write_permission'), \ self._get_error_message(model_class, 'has_object_write_permission', action_method_name) return obj.has_object_write_permission(request)
python
def has_object_permission(self, request, view, obj): """ Overrides the standard function and figures out methods to call for object permissions. """ if not self.object_permissions: return True serializer_class = view.get_serializer_class() model_class = serializer_class.Meta.model action_method_name = None if hasattr(view, 'action'): action = self._get_action(view.action) action_method_name = "has_object_{action}_permission".format(action=action) # If the specific action permission exists then use it, otherwise use general. if hasattr(obj, action_method_name): return getattr(obj, action_method_name)(request) if request.method in permissions.SAFE_METHODS: assert hasattr(obj, 'has_object_read_permission'), \ self._get_error_message(model_class, 'has_object_read_permission', action_method_name) return obj.has_object_read_permission(request) else: assert hasattr(obj, 'has_object_write_permission'), \ self._get_error_message(model_class, 'has_object_write_permission', action_method_name) return obj.has_object_write_permission(request)
[ "def", "has_object_permission", "(", "self", ",", "request", ",", "view", ",", "obj", ")", ":", "if", "not", "self", ".", "object_permissions", ":", "return", "True", "serializer_class", "=", "view", ".", "get_serializer_class", "(", ")", "model_class", "=", "serializer_class", ".", "Meta", ".", "model", "action_method_name", "=", "None", "if", "hasattr", "(", "view", ",", "'action'", ")", ":", "action", "=", "self", ".", "_get_action", "(", "view", ".", "action", ")", "action_method_name", "=", "\"has_object_{action}_permission\"", ".", "format", "(", "action", "=", "action", ")", "# If the specific action permission exists then use it, otherwise use general.", "if", "hasattr", "(", "obj", ",", "action_method_name", ")", ":", "return", "getattr", "(", "obj", ",", "action_method_name", ")", "(", "request", ")", "if", "request", ".", "method", "in", "permissions", ".", "SAFE_METHODS", ":", "assert", "hasattr", "(", "obj", ",", "'has_object_read_permission'", ")", ",", "self", ".", "_get_error_message", "(", "model_class", ",", "'has_object_read_permission'", ",", "action_method_name", ")", "return", "obj", ".", "has_object_read_permission", "(", "request", ")", "else", ":", "assert", "hasattr", "(", "obj", ",", "'has_object_write_permission'", ")", ",", "self", ".", "_get_error_message", "(", "model_class", ",", "'has_object_write_permission'", ",", "action_method_name", ")", "return", "obj", ".", "has_object_write_permission", "(", "request", ")" ]
Overrides the standard function and figures out methods to call for object permissions.
[ "Overrides", "the", "standard", "function", "and", "figures", "out", "methods", "to", "call", "for", "object", "permissions", "." ]
b2d4d3c76041f6c405e2537bea9639657b75b90e
https://github.com/dbkaplan/dry-rest-permissions/blob/b2d4d3c76041f6c405e2537bea9639657b75b90e/dry_rest_permissions/generics.py#L130-L154
train
dbkaplan/dry-rest-permissions
dry_rest_permissions/generics.py
DRYPermissions._get_action
def _get_action(self, action): """ Utility function that consolidates actions if necessary. """ return_action = action if self.partial_update_is_update and action == 'partial_update': return_action = 'update' return return_action
python
def _get_action(self, action): """ Utility function that consolidates actions if necessary. """ return_action = action if self.partial_update_is_update and action == 'partial_update': return_action = 'update' return return_action
[ "def", "_get_action", "(", "self", ",", "action", ")", ":", "return_action", "=", "action", "if", "self", ".", "partial_update_is_update", "and", "action", "==", "'partial_update'", ":", "return_action", "=", "'update'", "return", "return_action" ]
Utility function that consolidates actions if necessary.
[ "Utility", "function", "that", "consolidates", "actions", "if", "necessary", "." ]
b2d4d3c76041f6c405e2537bea9639657b75b90e
https://github.com/dbkaplan/dry-rest-permissions/blob/b2d4d3c76041f6c405e2537bea9639657b75b90e/dry_rest_permissions/generics.py#L156-L163
train
dbkaplan/dry-rest-permissions
dry_rest_permissions/generics.py
DRYPermissions._get_error_message
def _get_error_message(self, model_class, method_name, action_method_name): """ Get assertion error message depending if there are actions permissions methods defined. """ if action_method_name: return "'{}' does not have '{}' or '{}' defined.".format(model_class, method_name, action_method_name) else: return "'{}' does not have '{}' defined.".format(model_class, method_name)
python
def _get_error_message(self, model_class, method_name, action_method_name): """ Get assertion error message depending if there are actions permissions methods defined. """ if action_method_name: return "'{}' does not have '{}' or '{}' defined.".format(model_class, method_name, action_method_name) else: return "'{}' does not have '{}' defined.".format(model_class, method_name)
[ "def", "_get_error_message", "(", "self", ",", "model_class", ",", "method_name", ",", "action_method_name", ")", ":", "if", "action_method_name", ":", "return", "\"'{}' does not have '{}' or '{}' defined.\"", ".", "format", "(", "model_class", ",", "method_name", ",", "action_method_name", ")", "else", ":", "return", "\"'{}' does not have '{}' defined.\"", ".", "format", "(", "model_class", ",", "method_name", ")" ]
Get assertion error message depending if there are actions permissions methods defined.
[ "Get", "assertion", "error", "message", "depending", "if", "there", "are", "actions", "permissions", "methods", "defined", "." ]
b2d4d3c76041f6c405e2537bea9639657b75b90e
https://github.com/dbkaplan/dry-rest-permissions/blob/b2d4d3c76041f6c405e2537bea9639657b75b90e/dry_rest_permissions/generics.py#L165-L172
train
dbkaplan/dry-rest-permissions
dry_rest_permissions/generics.py
DRYPermissionsField.bind
def bind(self, field_name, parent): """ Check the model attached to the serializer to see what methods are defined and save them. """ assert parent.Meta.model is not None, \ "DRYPermissions is used on '{}' without a model".format(parent.__class__.__name__) for action in self.actions: if not self.object_only: global_method_name = "has_{action}_permission".format(action=action) if hasattr(parent.Meta.model, global_method_name): self.action_method_map[action] = {'global': global_method_name} if not self.global_only: object_method_name = "has_object_{action}_permission".format(action=action) if hasattr(parent.Meta.model, object_method_name): if self.action_method_map.get(action, None) is None: self.action_method_map[action] = {} self.action_method_map[action]['object'] = object_method_name super(DRYPermissionsField, self).bind(field_name, parent)
python
def bind(self, field_name, parent): """ Check the model attached to the serializer to see what methods are defined and save them. """ assert parent.Meta.model is not None, \ "DRYPermissions is used on '{}' without a model".format(parent.__class__.__name__) for action in self.actions: if not self.object_only: global_method_name = "has_{action}_permission".format(action=action) if hasattr(parent.Meta.model, global_method_name): self.action_method_map[action] = {'global': global_method_name} if not self.global_only: object_method_name = "has_object_{action}_permission".format(action=action) if hasattr(parent.Meta.model, object_method_name): if self.action_method_map.get(action, None) is None: self.action_method_map[action] = {} self.action_method_map[action]['object'] = object_method_name super(DRYPermissionsField, self).bind(field_name, parent)
[ "def", "bind", "(", "self", ",", "field_name", ",", "parent", ")", ":", "assert", "parent", ".", "Meta", ".", "model", "is", "not", "None", ",", "\"DRYPermissions is used on '{}' without a model\"", ".", "format", "(", "parent", ".", "__class__", ".", "__name__", ")", "for", "action", "in", "self", ".", "actions", ":", "if", "not", "self", ".", "object_only", ":", "global_method_name", "=", "\"has_{action}_permission\"", ".", "format", "(", "action", "=", "action", ")", "if", "hasattr", "(", "parent", ".", "Meta", ".", "model", ",", "global_method_name", ")", ":", "self", ".", "action_method_map", "[", "action", "]", "=", "{", "'global'", ":", "global_method_name", "}", "if", "not", "self", ".", "global_only", ":", "object_method_name", "=", "\"has_object_{action}_permission\"", ".", "format", "(", "action", "=", "action", ")", "if", "hasattr", "(", "parent", ".", "Meta", ".", "model", ",", "object_method_name", ")", ":", "if", "self", ".", "action_method_map", ".", "get", "(", "action", ",", "None", ")", "is", "None", ":", "self", ".", "action_method_map", "[", "action", "]", "=", "{", "}", "self", ".", "action_method_map", "[", "action", "]", "[", "'object'", "]", "=", "object_method_name", "super", "(", "DRYPermissionsField", ",", "self", ")", ".", "bind", "(", "field_name", ",", "parent", ")" ]
Check the model attached to the serializer to see what methods are defined and save them.
[ "Check", "the", "model", "attached", "to", "the", "serializer", "to", "see", "what", "methods", "are", "defined", "and", "save", "them", "." ]
b2d4d3c76041f6c405e2537bea9639657b75b90e
https://github.com/dbkaplan/dry-rest-permissions/blob/b2d4d3c76041f6c405e2537bea9639657b75b90e/dry_rest_permissions/generics.py#L229-L250
train
toastdriven/restless
restless/resources.py
skip_prepare
def skip_prepare(func): """ A convenience decorator for indicating the raw data should not be prepared. """ @wraps(func) def _wrapper(self, *args, **kwargs): value = func(self, *args, **kwargs) return Data(value, should_prepare=False) return _wrapper
python
def skip_prepare(func): """ A convenience decorator for indicating the raw data should not be prepared. """ @wraps(func) def _wrapper(self, *args, **kwargs): value = func(self, *args, **kwargs) return Data(value, should_prepare=False) return _wrapper
[ "def", "skip_prepare", "(", "func", ")", ":", "@", "wraps", "(", "func", ")", "def", "_wrapper", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "value", "=", "func", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", "return", "Data", "(", "value", ",", "should_prepare", "=", "False", ")", "return", "_wrapper" ]
A convenience decorator for indicating the raw data should not be prepared.
[ "A", "convenience", "decorator", "for", "indicating", "the", "raw", "data", "should", "not", "be", "prepared", "." ]
661593b7b43c42d1bc508dec795356297991255e
https://github.com/toastdriven/restless/blob/661593b7b43c42d1bc508dec795356297991255e/restless/resources.py#L12-L20
train
toastdriven/restless
restless/resources.py
Resource.build_error
def build_error(self, err): """ When an exception is encountered, this generates a JSON error message for display to the user. :param err: The exception seen. The message is exposed to the user, so beware of sensitive data leaking. :type err: Exception :returns: A response object """ data = { 'error': err.args[0], } if self.is_debug(): # Add the traceback. data['traceback'] = format_traceback(sys.exc_info()) body = self.serializer.serialize(data) status = getattr(err, 'status', 500) return self.build_response(body, status=status)
python
def build_error(self, err): """ When an exception is encountered, this generates a JSON error message for display to the user. :param err: The exception seen. The message is exposed to the user, so beware of sensitive data leaking. :type err: Exception :returns: A response object """ data = { 'error': err.args[0], } if self.is_debug(): # Add the traceback. data['traceback'] = format_traceback(sys.exc_info()) body = self.serializer.serialize(data) status = getattr(err, 'status', 500) return self.build_response(body, status=status)
[ "def", "build_error", "(", "self", ",", "err", ")", ":", "data", "=", "{", "'error'", ":", "err", ".", "args", "[", "0", "]", ",", "}", "if", "self", ".", "is_debug", "(", ")", ":", "# Add the traceback.", "data", "[", "'traceback'", "]", "=", "format_traceback", "(", "sys", ".", "exc_info", "(", ")", ")", "body", "=", "self", ".", "serializer", ".", "serialize", "(", "data", ")", "status", "=", "getattr", "(", "err", ",", "'status'", ",", "500", ")", "return", "self", ".", "build_response", "(", "body", ",", "status", "=", "status", ")" ]
When an exception is encountered, this generates a JSON error message for display to the user. :param err: The exception seen. The message is exposed to the user, so beware of sensitive data leaking. :type err: Exception :returns: A response object
[ "When", "an", "exception", "is", "encountered", "this", "generates", "a", "JSON", "error", "message", "for", "display", "to", "the", "user", "." ]
661593b7b43c42d1bc508dec795356297991255e
https://github.com/toastdriven/restless/blob/661593b7b43c42d1bc508dec795356297991255e/restless/resources.py#L192-L213
train
toastdriven/restless
restless/resources.py
Resource.deserialize
def deserialize(self, method, endpoint, body): """ A convenience method for deserializing the body of a request. If called on a list-style endpoint, this calls ``deserialize_list``. Otherwise, it will call ``deserialize_detail``. :param method: The HTTP method of the current request :type method: string :param endpoint: The endpoint style (``list`` or ``detail``) :type endpoint: string :param body: The body of the current request :type body: string :returns: The deserialized data :rtype: ``list`` or ``dict`` """ if endpoint == 'list': return self.deserialize_list(body) return self.deserialize_detail(body)
python
def deserialize(self, method, endpoint, body): """ A convenience method for deserializing the body of a request. If called on a list-style endpoint, this calls ``deserialize_list``. Otherwise, it will call ``deserialize_detail``. :param method: The HTTP method of the current request :type method: string :param endpoint: The endpoint style (``list`` or ``detail``) :type endpoint: string :param body: The body of the current request :type body: string :returns: The deserialized data :rtype: ``list`` or ``dict`` """ if endpoint == 'list': return self.deserialize_list(body) return self.deserialize_detail(body)
[ "def", "deserialize", "(", "self", ",", "method", ",", "endpoint", ",", "body", ")", ":", "if", "endpoint", "==", "'list'", ":", "return", "self", ".", "deserialize_list", "(", "body", ")", "return", "self", ".", "deserialize_detail", "(", "body", ")" ]
A convenience method for deserializing the body of a request. If called on a list-style endpoint, this calls ``deserialize_list``. Otherwise, it will call ``deserialize_detail``. :param method: The HTTP method of the current request :type method: string :param endpoint: The endpoint style (``list`` or ``detail``) :type endpoint: string :param body: The body of the current request :type body: string :returns: The deserialized data :rtype: ``list`` or ``dict``
[ "A", "convenience", "method", "for", "deserializing", "the", "body", "of", "a", "request", "." ]
661593b7b43c42d1bc508dec795356297991255e
https://github.com/toastdriven/restless/blob/661593b7b43c42d1bc508dec795356297991255e/restless/resources.py#L310-L332
train
toastdriven/restless
restless/resources.py
Resource.serialize
def serialize(self, method, endpoint, data): """ A convenience method for serializing data for a response. If called on a list-style endpoint, this calls ``serialize_list``. Otherwise, it will call ``serialize_detail``. :param method: The HTTP method of the current request :type method: string :param endpoint: The endpoint style (``list`` or ``detail``) :type endpoint: string :param data: The body for the response :type data: string :returns: A serialized version of the data :rtype: string """ if endpoint == 'list': # Create is a special-case, because you POST it to the collection, # not to a detail. if method == 'POST': return self.serialize_detail(data) return self.serialize_list(data) return self.serialize_detail(data)
python
def serialize(self, method, endpoint, data): """ A convenience method for serializing data for a response. If called on a list-style endpoint, this calls ``serialize_list``. Otherwise, it will call ``serialize_detail``. :param method: The HTTP method of the current request :type method: string :param endpoint: The endpoint style (``list`` or ``detail``) :type endpoint: string :param data: The body for the response :type data: string :returns: A serialized version of the data :rtype: string """ if endpoint == 'list': # Create is a special-case, because you POST it to the collection, # not to a detail. if method == 'POST': return self.serialize_detail(data) return self.serialize_list(data) return self.serialize_detail(data)
[ "def", "serialize", "(", "self", ",", "method", ",", "endpoint", ",", "data", ")", ":", "if", "endpoint", "==", "'list'", ":", "# Create is a special-case, because you POST it to the collection,", "# not to a detail.", "if", "method", "==", "'POST'", ":", "return", "self", ".", "serialize_detail", "(", "data", ")", "return", "self", ".", "serialize_list", "(", "data", ")", "return", "self", ".", "serialize_detail", "(", "data", ")" ]
A convenience method for serializing data for a response. If called on a list-style endpoint, this calls ``serialize_list``. Otherwise, it will call ``serialize_detail``. :param method: The HTTP method of the current request :type method: string :param endpoint: The endpoint style (``list`` or ``detail``) :type endpoint: string :param data: The body for the response :type data: string :returns: A serialized version of the data :rtype: string
[ "A", "convenience", "method", "for", "serializing", "data", "for", "a", "response", "." ]
661593b7b43c42d1bc508dec795356297991255e
https://github.com/toastdriven/restless/blob/661593b7b43c42d1bc508dec795356297991255e/restless/resources.py#L362-L388
train
toastdriven/restless
restless/tnd.py
_method
def _method(self, *args, **kwargs): """ the body of those http-methods used in tornado.web.RequestHandler """ yield self.resource_handler.handle(self.__resource_view_type__, *args, **kwargs)
python
def _method(self, *args, **kwargs): """ the body of those http-methods used in tornado.web.RequestHandler """ yield self.resource_handler.handle(self.__resource_view_type__, *args, **kwargs)
[ "def", "_method", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "yield", "self", ".", "resource_handler", ".", "handle", "(", "self", ".", "__resource_view_type__", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]
the body of those http-methods used in tornado.web.RequestHandler
[ "the", "body", "of", "those", "http", "-", "methods", "used", "in", "tornado", ".", "web", ".", "RequestHandler" ]
661593b7b43c42d1bc508dec795356297991255e
https://github.com/toastdriven/restless/blob/661593b7b43c42d1bc508dec795356297991255e/restless/tnd.py#L36-L40
train
toastdriven/restless
restless/tnd.py
TornadoResource.as_view
def as_view(cls, view_type, *init_args, **init_kwargs): """ Return a subclass of tornado.web.RequestHandler and apply required setting. """ global _method new_cls = type( cls.__name__ + '_' + _BridgeMixin.__name__ + '_restless', (_BridgeMixin, cls._request_handler_base_,), dict( __resource_cls__=cls, __resource_args__=init_args, __resource_kwargs__=init_kwargs, __resource_view_type__=view_type) ) """ Add required http-methods to the newly created class We need to scan through MRO to find what functions users declared, and then add corresponding http-methods used by Tornado. """ bases = inspect.getmro(cls) bases = bases[0:bases.index(Resource)-1] for k, v in cls.http_methods[view_type].items(): if any(v in base_cls.__dict__ for base_cls in bases): setattr(new_cls, k.lower(), _method) return new_cls
python
def as_view(cls, view_type, *init_args, **init_kwargs): """ Return a subclass of tornado.web.RequestHandler and apply required setting. """ global _method new_cls = type( cls.__name__ + '_' + _BridgeMixin.__name__ + '_restless', (_BridgeMixin, cls._request_handler_base_,), dict( __resource_cls__=cls, __resource_args__=init_args, __resource_kwargs__=init_kwargs, __resource_view_type__=view_type) ) """ Add required http-methods to the newly created class We need to scan through MRO to find what functions users declared, and then add corresponding http-methods used by Tornado. """ bases = inspect.getmro(cls) bases = bases[0:bases.index(Resource)-1] for k, v in cls.http_methods[view_type].items(): if any(v in base_cls.__dict__ for base_cls in bases): setattr(new_cls, k.lower(), _method) return new_cls
[ "def", "as_view", "(", "cls", ",", "view_type", ",", "*", "init_args", ",", "*", "*", "init_kwargs", ")", ":", "global", "_method", "new_cls", "=", "type", "(", "cls", ".", "__name__", "+", "'_'", "+", "_BridgeMixin", ".", "__name__", "+", "'_restless'", ",", "(", "_BridgeMixin", ",", "cls", ".", "_request_handler_base_", ",", ")", ",", "dict", "(", "__resource_cls__", "=", "cls", ",", "__resource_args__", "=", "init_args", ",", "__resource_kwargs__", "=", "init_kwargs", ",", "__resource_view_type__", "=", "view_type", ")", ")", "\"\"\"\n Add required http-methods to the newly created class\n We need to scan through MRO to find what functions users declared,\n and then add corresponding http-methods used by Tornado.\n \"\"\"", "bases", "=", "inspect", ".", "getmro", "(", "cls", ")", "bases", "=", "bases", "[", "0", ":", "bases", ".", "index", "(", "Resource", ")", "-", "1", "]", "for", "k", ",", "v", "in", "cls", ".", "http_methods", "[", "view_type", "]", ".", "items", "(", ")", ":", "if", "any", "(", "v", "in", "base_cls", ".", "__dict__", "for", "base_cls", "in", "bases", ")", ":", "setattr", "(", "new_cls", ",", "k", ".", "lower", "(", ")", ",", "_method", ")", "return", "new_cls" ]
Return a subclass of tornado.web.RequestHandler and apply required setting.
[ "Return", "a", "subclass", "of", "tornado", ".", "web", ".", "RequestHandler", "and", "apply", "required", "setting", "." ]
661593b7b43c42d1bc508dec795356297991255e
https://github.com/toastdriven/restless/blob/661593b7b43c42d1bc508dec795356297991255e/restless/tnd.py#L95-L123
train
toastdriven/restless
restless/tnd.py
TornadoResource.handle
def handle(self, endpoint, *args, **kwargs): """ almost identical to Resource.handle, except the way we handle the return value of view_method. """ method = self.request_method() try: if not method in self.http_methods.get(endpoint, {}): raise MethodNotImplemented( "Unsupported method '{}' for {} endpoint.".format( method, endpoint ) ) if not self.is_authenticated(): raise Unauthorized() self.data = self.deserialize(method, endpoint, self.request_body()) view_method = getattr(self, self.http_methods[endpoint][method]) data = view_method(*args, **kwargs) if is_future(data): # need to check if the view_method is a generator or not data = yield data serialized = self.serialize(method, endpoint, data) except Exception as err: raise gen.Return(self.handle_error(err)) status = self.status_map.get(self.http_methods[endpoint][method], OK) raise gen.Return(self.build_response(serialized, status=status))
python
def handle(self, endpoint, *args, **kwargs): """ almost identical to Resource.handle, except the way we handle the return value of view_method. """ method = self.request_method() try: if not method in self.http_methods.get(endpoint, {}): raise MethodNotImplemented( "Unsupported method '{}' for {} endpoint.".format( method, endpoint ) ) if not self.is_authenticated(): raise Unauthorized() self.data = self.deserialize(method, endpoint, self.request_body()) view_method = getattr(self, self.http_methods[endpoint][method]) data = view_method(*args, **kwargs) if is_future(data): # need to check if the view_method is a generator or not data = yield data serialized = self.serialize(method, endpoint, data) except Exception as err: raise gen.Return(self.handle_error(err)) status = self.status_map.get(self.http_methods[endpoint][method], OK) raise gen.Return(self.build_response(serialized, status=status))
[ "def", "handle", "(", "self", ",", "endpoint", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "method", "=", "self", ".", "request_method", "(", ")", "try", ":", "if", "not", "method", "in", "self", ".", "http_methods", ".", "get", "(", "endpoint", ",", "{", "}", ")", ":", "raise", "MethodNotImplemented", "(", "\"Unsupported method '{}' for {} endpoint.\"", ".", "format", "(", "method", ",", "endpoint", ")", ")", "if", "not", "self", ".", "is_authenticated", "(", ")", ":", "raise", "Unauthorized", "(", ")", "self", ".", "data", "=", "self", ".", "deserialize", "(", "method", ",", "endpoint", ",", "self", ".", "request_body", "(", ")", ")", "view_method", "=", "getattr", "(", "self", ",", "self", ".", "http_methods", "[", "endpoint", "]", "[", "method", "]", ")", "data", "=", "view_method", "(", "*", "args", ",", "*", "*", "kwargs", ")", "if", "is_future", "(", "data", ")", ":", "# need to check if the view_method is a generator or not", "data", "=", "yield", "data", "serialized", "=", "self", ".", "serialize", "(", "method", ",", "endpoint", ",", "data", ")", "except", "Exception", "as", "err", ":", "raise", "gen", ".", "Return", "(", "self", ".", "handle_error", "(", "err", ")", ")", "status", "=", "self", ".", "status_map", ".", "get", "(", "self", ".", "http_methods", "[", "endpoint", "]", "[", "method", "]", ",", "OK", ")", "raise", "gen", ".", "Return", "(", "self", ".", "build_response", "(", "serialized", ",", "status", "=", "status", ")", ")" ]
almost identical to Resource.handle, except the way we handle the return value of view_method.
[ "almost", "identical", "to", "Resource", ".", "handle", "except", "the", "way", "we", "handle", "the", "return", "value", "of", "view_method", "." ]
661593b7b43c42d1bc508dec795356297991255e
https://github.com/toastdriven/restless/blob/661593b7b43c42d1bc508dec795356297991255e/restless/tnd.py#L147-L177
train
toastdriven/restless
restless/preparers.py
FieldsPreparer.prepare
def prepare(self, data): """ Handles transforming the provided data into the fielded data that should be exposed to the end user. Uses the ``lookup_data`` method to traverse dotted paths. Returns a dictionary of data as the response. """ result = {} if not self.fields: # No fields specified. Serialize everything. return data for fieldname, lookup in self.fields.items(): if isinstance(lookup, SubPreparer): result[fieldname] = lookup.prepare(data) else: result[fieldname] = self.lookup_data(lookup, data) return result
python
def prepare(self, data): """ Handles transforming the provided data into the fielded data that should be exposed to the end user. Uses the ``lookup_data`` method to traverse dotted paths. Returns a dictionary of data as the response. """ result = {} if not self.fields: # No fields specified. Serialize everything. return data for fieldname, lookup in self.fields.items(): if isinstance(lookup, SubPreparer): result[fieldname] = lookup.prepare(data) else: result[fieldname] = self.lookup_data(lookup, data) return result
[ "def", "prepare", "(", "self", ",", "data", ")", ":", "result", "=", "{", "}", "if", "not", "self", ".", "fields", ":", "# No fields specified. Serialize everything.", "return", "data", "for", "fieldname", ",", "lookup", "in", "self", ".", "fields", ".", "items", "(", ")", ":", "if", "isinstance", "(", "lookup", ",", "SubPreparer", ")", ":", "result", "[", "fieldname", "]", "=", "lookup", ".", "prepare", "(", "data", ")", "else", ":", "result", "[", "fieldname", "]", "=", "self", ".", "lookup_data", "(", "lookup", ",", "data", ")", "return", "result" ]
Handles transforming the provided data into the fielded data that should be exposed to the end user. Uses the ``lookup_data`` method to traverse dotted paths. Returns a dictionary of data as the response.
[ "Handles", "transforming", "the", "provided", "data", "into", "the", "fielded", "data", "that", "should", "be", "exposed", "to", "the", "end", "user", "." ]
661593b7b43c42d1bc508dec795356297991255e
https://github.com/toastdriven/restless/blob/661593b7b43c42d1bc508dec795356297991255e/restless/preparers.py#L42-L63
train
toastdriven/restless
restless/preparers.py
FieldsPreparer.lookup_data
def lookup_data(self, lookup, data): """ Given a lookup string, attempts to descend through nested data looking for the value. Can work with either dictionary-alikes or objects (or any combination of those). Lookups should be a string. If it is a dotted path, it will be split on ``.`` & it will traverse through to find the final value. If not, it will simply attempt to find either a key or attribute of that name & return it. Example:: >>> data = { ... 'type': 'message', ... 'greeting': { ... 'en': 'hello', ... 'fr': 'bonjour', ... 'es': 'hola', ... }, ... 'person': Person( ... name='daniel' ... ) ... } >>> lookup_data('type', data) 'message' >>> lookup_data('greeting.en', data) 'hello' >>> lookup_data('person.name', data) 'daniel' """ value = data parts = lookup.split('.') if not parts or not parts[0]: return value part = parts[0] remaining_lookup = '.'.join(parts[1:]) if callable(getattr(data, 'keys', None)) and hasattr(data, '__getitem__'): # Dictionary enough for us. value = data[part] elif data is not None: # Assume it's an object. value = getattr(data, part) # Call if it's callable except if it's a Django DB manager instance # We check if is a manager by checking the db_manager (duck typing) if callable(value) and not hasattr(value, 'db_manager'): value = value() if not remaining_lookup: return value # There's more to lookup, so dive in recursively. return self.lookup_data(remaining_lookup, value)
python
def lookup_data(self, lookup, data): """ Given a lookup string, attempts to descend through nested data looking for the value. Can work with either dictionary-alikes or objects (or any combination of those). Lookups should be a string. If it is a dotted path, it will be split on ``.`` & it will traverse through to find the final value. If not, it will simply attempt to find either a key or attribute of that name & return it. Example:: >>> data = { ... 'type': 'message', ... 'greeting': { ... 'en': 'hello', ... 'fr': 'bonjour', ... 'es': 'hola', ... }, ... 'person': Person( ... name='daniel' ... ) ... } >>> lookup_data('type', data) 'message' >>> lookup_data('greeting.en', data) 'hello' >>> lookup_data('person.name', data) 'daniel' """ value = data parts = lookup.split('.') if not parts or not parts[0]: return value part = parts[0] remaining_lookup = '.'.join(parts[1:]) if callable(getattr(data, 'keys', None)) and hasattr(data, '__getitem__'): # Dictionary enough for us. value = data[part] elif data is not None: # Assume it's an object. value = getattr(data, part) # Call if it's callable except if it's a Django DB manager instance # We check if is a manager by checking the db_manager (duck typing) if callable(value) and not hasattr(value, 'db_manager'): value = value() if not remaining_lookup: return value # There's more to lookup, so dive in recursively. return self.lookup_data(remaining_lookup, value)
[ "def", "lookup_data", "(", "self", ",", "lookup", ",", "data", ")", ":", "value", "=", "data", "parts", "=", "lookup", ".", "split", "(", "'.'", ")", "if", "not", "parts", "or", "not", "parts", "[", "0", "]", ":", "return", "value", "part", "=", "parts", "[", "0", "]", "remaining_lookup", "=", "'.'", ".", "join", "(", "parts", "[", "1", ":", "]", ")", "if", "callable", "(", "getattr", "(", "data", ",", "'keys'", ",", "None", ")", ")", "and", "hasattr", "(", "data", ",", "'__getitem__'", ")", ":", "# Dictionary enough for us.", "value", "=", "data", "[", "part", "]", "elif", "data", "is", "not", "None", ":", "# Assume it's an object.", "value", "=", "getattr", "(", "data", ",", "part", ")", "# Call if it's callable except if it's a Django DB manager instance", "# We check if is a manager by checking the db_manager (duck typing)", "if", "callable", "(", "value", ")", "and", "not", "hasattr", "(", "value", ",", "'db_manager'", ")", ":", "value", "=", "value", "(", ")", "if", "not", "remaining_lookup", ":", "return", "value", "# There's more to lookup, so dive in recursively.", "return", "self", ".", "lookup_data", "(", "remaining_lookup", ",", "value", ")" ]
Given a lookup string, attempts to descend through nested data looking for the value. Can work with either dictionary-alikes or objects (or any combination of those). Lookups should be a string. If it is a dotted path, it will be split on ``.`` & it will traverse through to find the final value. If not, it will simply attempt to find either a key or attribute of that name & return it. Example:: >>> data = { ... 'type': 'message', ... 'greeting': { ... 'en': 'hello', ... 'fr': 'bonjour', ... 'es': 'hola', ... }, ... 'person': Person( ... name='daniel' ... ) ... } >>> lookup_data('type', data) 'message' >>> lookup_data('greeting.en', data) 'hello' >>> lookup_data('person.name', data) 'daniel'
[ "Given", "a", "lookup", "string", "attempts", "to", "descend", "through", "nested", "data", "looking", "for", "the", "value", "." ]
661593b7b43c42d1bc508dec795356297991255e
https://github.com/toastdriven/restless/blob/661593b7b43c42d1bc508dec795356297991255e/restless/preparers.py#L65-L123
train
toastdriven/restless
restless/preparers.py
CollectionSubPreparer.prepare
def prepare(self, data): """ Handles passing each item in the collection data to the configured subpreparer. Uses a loop and the ``get_inner_data`` method to provide the correct item of the data. Returns a list of data as the response. """ result = [] for item in self.get_inner_data(data): result.append(self.preparer.prepare(item)) return result
python
def prepare(self, data): """ Handles passing each item in the collection data to the configured subpreparer. Uses a loop and the ``get_inner_data`` method to provide the correct item of the data. Returns a list of data as the response. """ result = [] for item in self.get_inner_data(data): result.append(self.preparer.prepare(item)) return result
[ "def", "prepare", "(", "self", ",", "data", ")", ":", "result", "=", "[", "]", "for", "item", "in", "self", ".", "get_inner_data", "(", "data", ")", ":", "result", ".", "append", "(", "self", ".", "preparer", ".", "prepare", "(", "item", ")", ")", "return", "result" ]
Handles passing each item in the collection data to the configured subpreparer. Uses a loop and the ``get_inner_data`` method to provide the correct item of the data. Returns a list of data as the response.
[ "Handles", "passing", "each", "item", "in", "the", "collection", "data", "to", "the", "configured", "subpreparer", "." ]
661593b7b43c42d1bc508dec795356297991255e
https://github.com/toastdriven/restless/blob/661593b7b43c42d1bc508dec795356297991255e/restless/preparers.py#L201-L216
train
toastdriven/restless
restless/dj.py
DjangoResource.build_url_name
def build_url_name(cls, name, name_prefix=None): """ Given a ``name`` & an optional ``name_prefix``, this generates a name for a URL. :param name: The name for the URL (ex. 'detail') :type name: string :param name_prefix: (Optional) A prefix for the URL's name (for resolving). The default is ``None``, which will autocreate a prefix based on the class name. Ex: ``BlogPostResource`` -> ``api_blog_post_list`` :type name_prefix: string :returns: The final name :rtype: string """ if name_prefix is None: name_prefix = 'api_{}'.format( cls.__name__.replace('Resource', '').lower() ) name_prefix = name_prefix.rstrip('_') return '_'.join([name_prefix, name])
python
def build_url_name(cls, name, name_prefix=None): """ Given a ``name`` & an optional ``name_prefix``, this generates a name for a URL. :param name: The name for the URL (ex. 'detail') :type name: string :param name_prefix: (Optional) A prefix for the URL's name (for resolving). The default is ``None``, which will autocreate a prefix based on the class name. Ex: ``BlogPostResource`` -> ``api_blog_post_list`` :type name_prefix: string :returns: The final name :rtype: string """ if name_prefix is None: name_prefix = 'api_{}'.format( cls.__name__.replace('Resource', '').lower() ) name_prefix = name_prefix.rstrip('_') return '_'.join([name_prefix, name])
[ "def", "build_url_name", "(", "cls", ",", "name", ",", "name_prefix", "=", "None", ")", ":", "if", "name_prefix", "is", "None", ":", "name_prefix", "=", "'api_{}'", ".", "format", "(", "cls", ".", "__name__", ".", "replace", "(", "'Resource'", ",", "''", ")", ".", "lower", "(", ")", ")", "name_prefix", "=", "name_prefix", ".", "rstrip", "(", "'_'", ")", "return", "'_'", ".", "join", "(", "[", "name_prefix", ",", "name", "]", ")" ]
Given a ``name`` & an optional ``name_prefix``, this generates a name for a URL. :param name: The name for the URL (ex. 'detail') :type name: string :param name_prefix: (Optional) A prefix for the URL's name (for resolving). The default is ``None``, which will autocreate a prefix based on the class name. Ex: ``BlogPostResource`` -> ``api_blog_post_list`` :type name_prefix: string :returns: The final name :rtype: string
[ "Given", "a", "name", "&", "an", "optional", "name_prefix", "this", "generates", "a", "name", "for", "a", "URL", "." ]
661593b7b43c42d1bc508dec795356297991255e
https://github.com/toastdriven/restless/blob/661593b7b43c42d1bc508dec795356297991255e/restless/dj.py#L90-L113
train
toastdriven/restless
restless/fl.py
FlaskResource.build_endpoint_name
def build_endpoint_name(cls, name, endpoint_prefix=None): """ Given a ``name`` & an optional ``endpoint_prefix``, this generates a name for a URL. :param name: The name for the URL (ex. 'detail') :type name: string :param endpoint_prefix: (Optional) A prefix for the URL's name (for resolving). The default is ``None``, which will autocreate a prefix based on the class name. Ex: ``BlogPostResource`` -> ``api_blogpost_list`` :type endpoint_prefix: string :returns: The final name :rtype: string """ if endpoint_prefix is None: endpoint_prefix = 'api_{}'.format( cls.__name__.replace('Resource', '').lower() ) endpoint_prefix = endpoint_prefix.rstrip('_') return '_'.join([endpoint_prefix, name])
python
def build_endpoint_name(cls, name, endpoint_prefix=None): """ Given a ``name`` & an optional ``endpoint_prefix``, this generates a name for a URL. :param name: The name for the URL (ex. 'detail') :type name: string :param endpoint_prefix: (Optional) A prefix for the URL's name (for resolving). The default is ``None``, which will autocreate a prefix based on the class name. Ex: ``BlogPostResource`` -> ``api_blogpost_list`` :type endpoint_prefix: string :returns: The final name :rtype: string """ if endpoint_prefix is None: endpoint_prefix = 'api_{}'.format( cls.__name__.replace('Resource', '').lower() ) endpoint_prefix = endpoint_prefix.rstrip('_') return '_'.join([endpoint_prefix, name])
[ "def", "build_endpoint_name", "(", "cls", ",", "name", ",", "endpoint_prefix", "=", "None", ")", ":", "if", "endpoint_prefix", "is", "None", ":", "endpoint_prefix", "=", "'api_{}'", ".", "format", "(", "cls", ".", "__name__", ".", "replace", "(", "'Resource'", ",", "''", ")", ".", "lower", "(", ")", ")", "endpoint_prefix", "=", "endpoint_prefix", ".", "rstrip", "(", "'_'", ")", "return", "'_'", ".", "join", "(", "[", "endpoint_prefix", ",", "name", "]", ")" ]
Given a ``name`` & an optional ``endpoint_prefix``, this generates a name for a URL. :param name: The name for the URL (ex. 'detail') :type name: string :param endpoint_prefix: (Optional) A prefix for the URL's name (for resolving). The default is ``None``, which will autocreate a prefix based on the class name. Ex: ``BlogPostResource`` -> ``api_blogpost_list`` :type endpoint_prefix: string :returns: The final name :rtype: string
[ "Given", "a", "name", "&", "an", "optional", "endpoint_prefix", "this", "generates", "a", "name", "for", "a", "URL", "." ]
661593b7b43c42d1bc508dec795356297991255e
https://github.com/toastdriven/restless/blob/661593b7b43c42d1bc508dec795356297991255e/restless/fl.py#L59-L82
train
toastdriven/restless
restless/pyr.py
PyramidResource.build_routename
def build_routename(cls, name, routename_prefix=None): """ Given a ``name`` & an optional ``routename_prefix``, this generates a name for a URL. :param name: The name for the URL (ex. 'detail') :type name: string :param routename_prefix: (Optional) A prefix for the URL's name (for resolving). The default is ``None``, which will autocreate a prefix based on the class name. Ex: ``BlogPostResource`` -> ``api_blogpost_list`` :type routename_prefix: string :returns: The final name :rtype: string """ if routename_prefix is None: routename_prefix = 'api_{}'.format( cls.__name__.replace('Resource', '').lower() ) routename_prefix = routename_prefix.rstrip('_') return '_'.join([routename_prefix, name])
python
def build_routename(cls, name, routename_prefix=None): """ Given a ``name`` & an optional ``routename_prefix``, this generates a name for a URL. :param name: The name for the URL (ex. 'detail') :type name: string :param routename_prefix: (Optional) A prefix for the URL's name (for resolving). The default is ``None``, which will autocreate a prefix based on the class name. Ex: ``BlogPostResource`` -> ``api_blogpost_list`` :type routename_prefix: string :returns: The final name :rtype: string """ if routename_prefix is None: routename_prefix = 'api_{}'.format( cls.__name__.replace('Resource', '').lower() ) routename_prefix = routename_prefix.rstrip('_') return '_'.join([routename_prefix, name])
[ "def", "build_routename", "(", "cls", ",", "name", ",", "routename_prefix", "=", "None", ")", ":", "if", "routename_prefix", "is", "None", ":", "routename_prefix", "=", "'api_{}'", ".", "format", "(", "cls", ".", "__name__", ".", "replace", "(", "'Resource'", ",", "''", ")", ".", "lower", "(", ")", ")", "routename_prefix", "=", "routename_prefix", ".", "rstrip", "(", "'_'", ")", "return", "'_'", ".", "join", "(", "[", "routename_prefix", ",", "name", "]", ")" ]
Given a ``name`` & an optional ``routename_prefix``, this generates a name for a URL. :param name: The name for the URL (ex. 'detail') :type name: string :param routename_prefix: (Optional) A prefix for the URL's name (for resolving). The default is ``None``, which will autocreate a prefix based on the class name. Ex: ``BlogPostResource`` -> ``api_blogpost_list`` :type routename_prefix: string :returns: The final name :rtype: string
[ "Given", "a", "name", "&", "an", "optional", "routename_prefix", "this", "generates", "a", "name", "for", "a", "URL", "." ]
661593b7b43c42d1bc508dec795356297991255e
https://github.com/toastdriven/restless/blob/661593b7b43c42d1bc508dec795356297991255e/restless/pyr.py#L41-L64
train
toastdriven/restless
restless/pyr.py
PyramidResource.add_views
def add_views(cls, config, rule_prefix, routename_prefix=None): """ A convenience method for registering the routes and views in pyramid. This automatically adds a list and detail endpoint to your routes. :param config: The pyramid ``Configurator`` object for your app. :type config: ``pyramid.config.Configurator`` :param rule_prefix: The start of the URL to handle. :type rule_prefix: string :param routename_prefix: (Optional) A prefix for the route's name. The default is ``None``, which will autocreate a prefix based on the class name. Ex: ``PostResource`` -> ``api_post_list`` :type routename_prefix: string :returns: ``pyramid.config.Configurator`` """ methods = ('GET', 'POST', 'PUT', 'DELETE') config.add_route( cls.build_routename('list', routename_prefix), rule_prefix ) config.add_view( cls.as_list(), route_name=cls.build_routename('list', routename_prefix), request_method=methods ) config.add_route( cls.build_routename('detail', routename_prefix), rule_prefix + '{name}/' ) config.add_view( cls.as_detail(), route_name=cls.build_routename('detail', routename_prefix), request_method=methods ) return config
python
def add_views(cls, config, rule_prefix, routename_prefix=None): """ A convenience method for registering the routes and views in pyramid. This automatically adds a list and detail endpoint to your routes. :param config: The pyramid ``Configurator`` object for your app. :type config: ``pyramid.config.Configurator`` :param rule_prefix: The start of the URL to handle. :type rule_prefix: string :param routename_prefix: (Optional) A prefix for the route's name. The default is ``None``, which will autocreate a prefix based on the class name. Ex: ``PostResource`` -> ``api_post_list`` :type routename_prefix: string :returns: ``pyramid.config.Configurator`` """ methods = ('GET', 'POST', 'PUT', 'DELETE') config.add_route( cls.build_routename('list', routename_prefix), rule_prefix ) config.add_view( cls.as_list(), route_name=cls.build_routename('list', routename_prefix), request_method=methods ) config.add_route( cls.build_routename('detail', routename_prefix), rule_prefix + '{name}/' ) config.add_view( cls.as_detail(), route_name=cls.build_routename('detail', routename_prefix), request_method=methods ) return config
[ "def", "add_views", "(", "cls", ",", "config", ",", "rule_prefix", ",", "routename_prefix", "=", "None", ")", ":", "methods", "=", "(", "'GET'", ",", "'POST'", ",", "'PUT'", ",", "'DELETE'", ")", "config", ".", "add_route", "(", "cls", ".", "build_routename", "(", "'list'", ",", "routename_prefix", ")", ",", "rule_prefix", ")", "config", ".", "add_view", "(", "cls", ".", "as_list", "(", ")", ",", "route_name", "=", "cls", ".", "build_routename", "(", "'list'", ",", "routename_prefix", ")", ",", "request_method", "=", "methods", ")", "config", ".", "add_route", "(", "cls", ".", "build_routename", "(", "'detail'", ",", "routename_prefix", ")", ",", "rule_prefix", "+", "'{name}/'", ")", "config", ".", "add_view", "(", "cls", ".", "as_detail", "(", ")", ",", "route_name", "=", "cls", ".", "build_routename", "(", "'detail'", ",", "routename_prefix", ")", ",", "request_method", "=", "methods", ")", "return", "config" ]
A convenience method for registering the routes and views in pyramid. This automatically adds a list and detail endpoint to your routes. :param config: The pyramid ``Configurator`` object for your app. :type config: ``pyramid.config.Configurator`` :param rule_prefix: The start of the URL to handle. :type rule_prefix: string :param routename_prefix: (Optional) A prefix for the route's name. The default is ``None``, which will autocreate a prefix based on the class name. Ex: ``PostResource`` -> ``api_post_list`` :type routename_prefix: string :returns: ``pyramid.config.Configurator``
[ "A", "convenience", "method", "for", "registering", "the", "routes", "and", "views", "in", "pyramid", "." ]
661593b7b43c42d1bc508dec795356297991255e
https://github.com/toastdriven/restless/blob/661593b7b43c42d1bc508dec795356297991255e/restless/pyr.py#L67-L107
train
toastdriven/restless
restless/serializers.py
JSONSerializer.deserialize
def deserialize(self, body): """ The low-level deserialization. Underpins ``deserialize``, ``deserialize_list`` & ``deserialize_detail``. Has no built-in smarts, simply loads the JSON. :param body: The body of the current request :type body: string :returns: The deserialized data :rtype: ``list`` or ``dict`` """ try: if isinstance(body, bytes): return json.loads(body.decode('utf-8')) return json.loads(body) except ValueError: raise BadRequest('Request body is not valid JSON')
python
def deserialize(self, body): """ The low-level deserialization. Underpins ``deserialize``, ``deserialize_list`` & ``deserialize_detail``. Has no built-in smarts, simply loads the JSON. :param body: The body of the current request :type body: string :returns: The deserialized data :rtype: ``list`` or ``dict`` """ try: if isinstance(body, bytes): return json.loads(body.decode('utf-8')) return json.loads(body) except ValueError: raise BadRequest('Request body is not valid JSON')
[ "def", "deserialize", "(", "self", ",", "body", ")", ":", "try", ":", "if", "isinstance", "(", "body", ",", "bytes", ")", ":", "return", "json", ".", "loads", "(", "body", ".", "decode", "(", "'utf-8'", ")", ")", "return", "json", ".", "loads", "(", "body", ")", "except", "ValueError", ":", "raise", "BadRequest", "(", "'Request body is not valid JSON'", ")" ]
The low-level deserialization. Underpins ``deserialize``, ``deserialize_list`` & ``deserialize_detail``. Has no built-in smarts, simply loads the JSON. :param body: The body of the current request :type body: string :returns: The deserialized data :rtype: ``list`` or ``dict``
[ "The", "low", "-", "level", "deserialization", "." ]
661593b7b43c42d1bc508dec795356297991255e
https://github.com/toastdriven/restless/blob/661593b7b43c42d1bc508dec795356297991255e/restless/serializers.py#L47-L67
train
mila-iqia/fuel
fuel/converters/mnist.py
convert_mnist
def convert_mnist(directory, output_directory, output_filename=None, dtype=None): """Converts the MNIST dataset to HDF5. Converts the MNIST dataset to an HDF5 dataset compatible with :class:`fuel.datasets.MNIST`. The converted dataset is saved as 'mnist.hdf5'. This method assumes the existence of the following files: `train-images-idx3-ubyte.gz`, `train-labels-idx1-ubyte.gz` `t10k-images-idx3-ubyte.gz`, `t10k-labels-idx1-ubyte.gz` It assumes the existence of the following files: * `train-images-idx3-ubyte.gz` * `train-labels-idx1-ubyte.gz` * `t10k-images-idx3-ubyte.gz` * `t10k-labels-idx1-ubyte.gz` Parameters ---------- directory : str Directory in which input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to `None`, in which case a name based on `dtype` will be used. dtype : str, optional Either 'float32', 'float64', or 'bool'. Defaults to `None`, in which case images will be returned in their original unsigned byte format. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset. """ if not output_filename: if dtype: output_filename = 'mnist_{}.hdf5'.format(dtype) else: output_filename = 'mnist.hdf5' output_path = os.path.join(output_directory, output_filename) h5file = h5py.File(output_path, mode='w') train_feat_path = os.path.join(directory, TRAIN_IMAGES) train_features = read_mnist_images(train_feat_path, dtype) train_lab_path = os.path.join(directory, TRAIN_LABELS) train_labels = read_mnist_labels(train_lab_path) test_feat_path = os.path.join(directory, TEST_IMAGES) test_features = read_mnist_images(test_feat_path, dtype) test_lab_path = os.path.join(directory, TEST_LABELS) test_labels = read_mnist_labels(test_lab_path) data = (('train', 'features', train_features), ('train', 'targets', train_labels), ('test', 'features', test_features), ('test', 'targets', test_labels)) fill_hdf5_file(h5file, data) h5file['features'].dims[0].label = 'batch' h5file['features'].dims[1].label = 'channel' h5file['features'].dims[2].label = 'height' h5file['features'].dims[3].label = 'width' h5file['targets'].dims[0].label = 'batch' h5file['targets'].dims[1].label = 'index' h5file.flush() h5file.close() return (output_path,)
python
def convert_mnist(directory, output_directory, output_filename=None, dtype=None): """Converts the MNIST dataset to HDF5. Converts the MNIST dataset to an HDF5 dataset compatible with :class:`fuel.datasets.MNIST`. The converted dataset is saved as 'mnist.hdf5'. This method assumes the existence of the following files: `train-images-idx3-ubyte.gz`, `train-labels-idx1-ubyte.gz` `t10k-images-idx3-ubyte.gz`, `t10k-labels-idx1-ubyte.gz` It assumes the existence of the following files: * `train-images-idx3-ubyte.gz` * `train-labels-idx1-ubyte.gz` * `t10k-images-idx3-ubyte.gz` * `t10k-labels-idx1-ubyte.gz` Parameters ---------- directory : str Directory in which input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to `None`, in which case a name based on `dtype` will be used. dtype : str, optional Either 'float32', 'float64', or 'bool'. Defaults to `None`, in which case images will be returned in their original unsigned byte format. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset. """ if not output_filename: if dtype: output_filename = 'mnist_{}.hdf5'.format(dtype) else: output_filename = 'mnist.hdf5' output_path = os.path.join(output_directory, output_filename) h5file = h5py.File(output_path, mode='w') train_feat_path = os.path.join(directory, TRAIN_IMAGES) train_features = read_mnist_images(train_feat_path, dtype) train_lab_path = os.path.join(directory, TRAIN_LABELS) train_labels = read_mnist_labels(train_lab_path) test_feat_path = os.path.join(directory, TEST_IMAGES) test_features = read_mnist_images(test_feat_path, dtype) test_lab_path = os.path.join(directory, TEST_LABELS) test_labels = read_mnist_labels(test_lab_path) data = (('train', 'features', train_features), ('train', 'targets', train_labels), ('test', 'features', test_features), ('test', 'targets', test_labels)) fill_hdf5_file(h5file, data) h5file['features'].dims[0].label = 'batch' h5file['features'].dims[1].label = 'channel' h5file['features'].dims[2].label = 'height' h5file['features'].dims[3].label = 'width' h5file['targets'].dims[0].label = 'batch' h5file['targets'].dims[1].label = 'index' h5file.flush() h5file.close() return (output_path,)
[ "def", "convert_mnist", "(", "directory", ",", "output_directory", ",", "output_filename", "=", "None", ",", "dtype", "=", "None", ")", ":", "if", "not", "output_filename", ":", "if", "dtype", ":", "output_filename", "=", "'mnist_{}.hdf5'", ".", "format", "(", "dtype", ")", "else", ":", "output_filename", "=", "'mnist.hdf5'", "output_path", "=", "os", ".", "path", ".", "join", "(", "output_directory", ",", "output_filename", ")", "h5file", "=", "h5py", ".", "File", "(", "output_path", ",", "mode", "=", "'w'", ")", "train_feat_path", "=", "os", ".", "path", ".", "join", "(", "directory", ",", "TRAIN_IMAGES", ")", "train_features", "=", "read_mnist_images", "(", "train_feat_path", ",", "dtype", ")", "train_lab_path", "=", "os", ".", "path", ".", "join", "(", "directory", ",", "TRAIN_LABELS", ")", "train_labels", "=", "read_mnist_labels", "(", "train_lab_path", ")", "test_feat_path", "=", "os", ".", "path", ".", "join", "(", "directory", ",", "TEST_IMAGES", ")", "test_features", "=", "read_mnist_images", "(", "test_feat_path", ",", "dtype", ")", "test_lab_path", "=", "os", ".", "path", ".", "join", "(", "directory", ",", "TEST_LABELS", ")", "test_labels", "=", "read_mnist_labels", "(", "test_lab_path", ")", "data", "=", "(", "(", "'train'", ",", "'features'", ",", "train_features", ")", ",", "(", "'train'", ",", "'targets'", ",", "train_labels", ")", ",", "(", "'test'", ",", "'features'", ",", "test_features", ")", ",", "(", "'test'", ",", "'targets'", ",", "test_labels", ")", ")", "fill_hdf5_file", "(", "h5file", ",", "data", ")", "h5file", "[", "'features'", "]", ".", "dims", "[", "0", "]", ".", "label", "=", "'batch'", "h5file", "[", "'features'", "]", ".", "dims", "[", "1", "]", ".", "label", "=", "'channel'", "h5file", "[", "'features'", "]", ".", "dims", "[", "2", "]", ".", "label", "=", "'height'", "h5file", "[", "'features'", "]", ".", "dims", "[", "3", "]", ".", "label", "=", "'width'", "h5file", "[", "'targets'", "]", ".", "dims", "[", "0", "]", ".", "label", "=", "'batch'", "h5file", "[", "'targets'", "]", ".", "dims", "[", "1", "]", ".", "label", "=", "'index'", "h5file", ".", "flush", "(", ")", "h5file", ".", "close", "(", ")", "return", "(", "output_path", ",", ")" ]
Converts the MNIST dataset to HDF5. Converts the MNIST dataset to an HDF5 dataset compatible with :class:`fuel.datasets.MNIST`. The converted dataset is saved as 'mnist.hdf5'. This method assumes the existence of the following files: `train-images-idx3-ubyte.gz`, `train-labels-idx1-ubyte.gz` `t10k-images-idx3-ubyte.gz`, `t10k-labels-idx1-ubyte.gz` It assumes the existence of the following files: * `train-images-idx3-ubyte.gz` * `train-labels-idx1-ubyte.gz` * `t10k-images-idx3-ubyte.gz` * `t10k-labels-idx1-ubyte.gz` Parameters ---------- directory : str Directory in which input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to `None`, in which case a name based on `dtype` will be used. dtype : str, optional Either 'float32', 'float64', or 'bool'. Defaults to `None`, in which case images will be returned in their original unsigned byte format. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset.
[ "Converts", "the", "MNIST", "dataset", "to", "HDF5", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/mnist.py#L22-L92
train
mila-iqia/fuel
fuel/converters/mnist.py
fill_subparser
def fill_subparser(subparser): """Sets up a subparser to convert the MNIST dataset files. Parameters ---------- subparser : :class:`argparse.ArgumentParser` Subparser handling the `mnist` command. """ subparser.add_argument( "--dtype", help="dtype to save to; by default, images will be " + "returned in their original unsigned byte format", choices=('float32', 'float64', 'bool'), type=str, default=None) return convert_mnist
python
def fill_subparser(subparser): """Sets up a subparser to convert the MNIST dataset files. Parameters ---------- subparser : :class:`argparse.ArgumentParser` Subparser handling the `mnist` command. """ subparser.add_argument( "--dtype", help="dtype to save to; by default, images will be " + "returned in their original unsigned byte format", choices=('float32', 'float64', 'bool'), type=str, default=None) return convert_mnist
[ "def", "fill_subparser", "(", "subparser", ")", ":", "subparser", ".", "add_argument", "(", "\"--dtype\"", ",", "help", "=", "\"dtype to save to; by default, images will be \"", "+", "\"returned in their original unsigned byte format\"", ",", "choices", "=", "(", "'float32'", ",", "'float64'", ",", "'bool'", ")", ",", "type", "=", "str", ",", "default", "=", "None", ")", "return", "convert_mnist" ]
Sets up a subparser to convert the MNIST dataset files. Parameters ---------- subparser : :class:`argparse.ArgumentParser` Subparser handling the `mnist` command.
[ "Sets", "up", "a", "subparser", "to", "convert", "the", "MNIST", "dataset", "files", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/mnist.py#L95-L108
train
mila-iqia/fuel
fuel/converters/mnist.py
read_mnist_images
def read_mnist_images(filename, dtype=None): """Read MNIST images from the original ubyte file format. Parameters ---------- filename : str Filename/path from which to read images. dtype : 'float32', 'float64', or 'bool' If unspecified, images will be returned in their original unsigned byte format. Returns ------- images : :class:`~numpy.ndarray`, shape (n_images, 1, n_rows, n_cols) An image array, with individual examples indexed along the first axis and the image dimensions along the second and third axis. Notes ----- If the dtype provided was Boolean, the resulting array will be Boolean with `True` if the corresponding pixel had a value greater than or equal to 128, `False` otherwise. If the dtype provided was a float dtype, the values will be mapped to the unit interval [0, 1], with pixel values that were 255 in the original unsigned byte representation equal to 1.0. """ with gzip.open(filename, 'rb') as f: magic, number, rows, cols = struct.unpack('>iiii', f.read(16)) if magic != MNIST_IMAGE_MAGIC: raise ValueError("Wrong magic number reading MNIST image file") array = numpy.frombuffer(f.read(), dtype='uint8') array = array.reshape((number, 1, rows, cols)) if dtype: dtype = numpy.dtype(dtype) if dtype.kind == 'b': # If the user wants Booleans, threshold at half the range. array = array >= 128 elif dtype.kind == 'f': # Otherwise, just convert. array = array.astype(dtype) array /= 255. else: raise ValueError("Unknown dtype to convert MNIST to") return array
python
def read_mnist_images(filename, dtype=None): """Read MNIST images from the original ubyte file format. Parameters ---------- filename : str Filename/path from which to read images. dtype : 'float32', 'float64', or 'bool' If unspecified, images will be returned in their original unsigned byte format. Returns ------- images : :class:`~numpy.ndarray`, shape (n_images, 1, n_rows, n_cols) An image array, with individual examples indexed along the first axis and the image dimensions along the second and third axis. Notes ----- If the dtype provided was Boolean, the resulting array will be Boolean with `True` if the corresponding pixel had a value greater than or equal to 128, `False` otherwise. If the dtype provided was a float dtype, the values will be mapped to the unit interval [0, 1], with pixel values that were 255 in the original unsigned byte representation equal to 1.0. """ with gzip.open(filename, 'rb') as f: magic, number, rows, cols = struct.unpack('>iiii', f.read(16)) if magic != MNIST_IMAGE_MAGIC: raise ValueError("Wrong magic number reading MNIST image file") array = numpy.frombuffer(f.read(), dtype='uint8') array = array.reshape((number, 1, rows, cols)) if dtype: dtype = numpy.dtype(dtype) if dtype.kind == 'b': # If the user wants Booleans, threshold at half the range. array = array >= 128 elif dtype.kind == 'f': # Otherwise, just convert. array = array.astype(dtype) array /= 255. else: raise ValueError("Unknown dtype to convert MNIST to") return array
[ "def", "read_mnist_images", "(", "filename", ",", "dtype", "=", "None", ")", ":", "with", "gzip", ".", "open", "(", "filename", ",", "'rb'", ")", "as", "f", ":", "magic", ",", "number", ",", "rows", ",", "cols", "=", "struct", ".", "unpack", "(", "'>iiii'", ",", "f", ".", "read", "(", "16", ")", ")", "if", "magic", "!=", "MNIST_IMAGE_MAGIC", ":", "raise", "ValueError", "(", "\"Wrong magic number reading MNIST image file\"", ")", "array", "=", "numpy", ".", "frombuffer", "(", "f", ".", "read", "(", ")", ",", "dtype", "=", "'uint8'", ")", "array", "=", "array", ".", "reshape", "(", "(", "number", ",", "1", ",", "rows", ",", "cols", ")", ")", "if", "dtype", ":", "dtype", "=", "numpy", ".", "dtype", "(", "dtype", ")", "if", "dtype", ".", "kind", "==", "'b'", ":", "# If the user wants Booleans, threshold at half the range.", "array", "=", "array", ">=", "128", "elif", "dtype", ".", "kind", "==", "'f'", ":", "# Otherwise, just convert.", "array", "=", "array", ".", "astype", "(", "dtype", ")", "array", "/=", "255.", "else", ":", "raise", "ValueError", "(", "\"Unknown dtype to convert MNIST to\"", ")", "return", "array" ]
Read MNIST images from the original ubyte file format. Parameters ---------- filename : str Filename/path from which to read images. dtype : 'float32', 'float64', or 'bool' If unspecified, images will be returned in their original unsigned byte format. Returns ------- images : :class:`~numpy.ndarray`, shape (n_images, 1, n_rows, n_cols) An image array, with individual examples indexed along the first axis and the image dimensions along the second and third axis. Notes ----- If the dtype provided was Boolean, the resulting array will be Boolean with `True` if the corresponding pixel had a value greater than or equal to 128, `False` otherwise. If the dtype provided was a float dtype, the values will be mapped to the unit interval [0, 1], with pixel values that were 255 in the original unsigned byte representation equal to 1.0.
[ "Read", "MNIST", "images", "from", "the", "original", "ubyte", "file", "format", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/mnist.py#L111-L159
train
mila-iqia/fuel
fuel/converters/mnist.py
read_mnist_labels
def read_mnist_labels(filename): """Read MNIST labels from the original ubyte file format. Parameters ---------- filename : str Filename/path from which to read labels. Returns ------- labels : :class:`~numpy.ndarray`, shape (nlabels, 1) A one-dimensional unsigned byte array containing the labels as integers. """ with gzip.open(filename, 'rb') as f: magic, _ = struct.unpack('>ii', f.read(8)) if magic != MNIST_LABEL_MAGIC: raise ValueError("Wrong magic number reading MNIST label file") array = numpy.frombuffer(f.read(), dtype='uint8') array = array.reshape(array.size, 1) return array
python
def read_mnist_labels(filename): """Read MNIST labels from the original ubyte file format. Parameters ---------- filename : str Filename/path from which to read labels. Returns ------- labels : :class:`~numpy.ndarray`, shape (nlabels, 1) A one-dimensional unsigned byte array containing the labels as integers. """ with gzip.open(filename, 'rb') as f: magic, _ = struct.unpack('>ii', f.read(8)) if magic != MNIST_LABEL_MAGIC: raise ValueError("Wrong magic number reading MNIST label file") array = numpy.frombuffer(f.read(), dtype='uint8') array = array.reshape(array.size, 1) return array
[ "def", "read_mnist_labels", "(", "filename", ")", ":", "with", "gzip", ".", "open", "(", "filename", ",", "'rb'", ")", "as", "f", ":", "magic", ",", "_", "=", "struct", ".", "unpack", "(", "'>ii'", ",", "f", ".", "read", "(", "8", ")", ")", "if", "magic", "!=", "MNIST_LABEL_MAGIC", ":", "raise", "ValueError", "(", "\"Wrong magic number reading MNIST label file\"", ")", "array", "=", "numpy", ".", "frombuffer", "(", "f", ".", "read", "(", ")", ",", "dtype", "=", "'uint8'", ")", "array", "=", "array", ".", "reshape", "(", "array", ".", "size", ",", "1", ")", "return", "array" ]
Read MNIST labels from the original ubyte file format. Parameters ---------- filename : str Filename/path from which to read labels. Returns ------- labels : :class:`~numpy.ndarray`, shape (nlabels, 1) A one-dimensional unsigned byte array containing the labels as integers.
[ "Read", "MNIST", "labels", "from", "the", "original", "ubyte", "file", "format", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/mnist.py#L162-L183
train
mila-iqia/fuel
fuel/converters/ilsvrc2010.py
prepare_hdf5_file
def prepare_hdf5_file(hdf5_file, n_train, n_valid, n_test): """Create datasets within a given HDF5 file. Parameters ---------- hdf5_file : :class:`h5py.File` instance HDF5 file handle to which to write. n_train : int The number of training set examples. n_valid : int The number of validation set examples. n_test : int The number of test set examples. """ n_total = n_train + n_valid + n_test splits = create_splits(n_train, n_valid, n_test) hdf5_file.attrs['split'] = H5PYDataset.create_split_array(splits) vlen_dtype = h5py.special_dtype(vlen=numpy.dtype('uint8')) hdf5_file.create_dataset('encoded_images', shape=(n_total,), dtype=vlen_dtype) hdf5_file.create_dataset('targets', shape=(n_total, 1), dtype=numpy.int16) hdf5_file.create_dataset('filenames', shape=(n_total, 1), dtype='S32')
python
def prepare_hdf5_file(hdf5_file, n_train, n_valid, n_test): """Create datasets within a given HDF5 file. Parameters ---------- hdf5_file : :class:`h5py.File` instance HDF5 file handle to which to write. n_train : int The number of training set examples. n_valid : int The number of validation set examples. n_test : int The number of test set examples. """ n_total = n_train + n_valid + n_test splits = create_splits(n_train, n_valid, n_test) hdf5_file.attrs['split'] = H5PYDataset.create_split_array(splits) vlen_dtype = h5py.special_dtype(vlen=numpy.dtype('uint8')) hdf5_file.create_dataset('encoded_images', shape=(n_total,), dtype=vlen_dtype) hdf5_file.create_dataset('targets', shape=(n_total, 1), dtype=numpy.int16) hdf5_file.create_dataset('filenames', shape=(n_total, 1), dtype='S32')
[ "def", "prepare_hdf5_file", "(", "hdf5_file", ",", "n_train", ",", "n_valid", ",", "n_test", ")", ":", "n_total", "=", "n_train", "+", "n_valid", "+", "n_test", "splits", "=", "create_splits", "(", "n_train", ",", "n_valid", ",", "n_test", ")", "hdf5_file", ".", "attrs", "[", "'split'", "]", "=", "H5PYDataset", ".", "create_split_array", "(", "splits", ")", "vlen_dtype", "=", "h5py", ".", "special_dtype", "(", "vlen", "=", "numpy", ".", "dtype", "(", "'uint8'", ")", ")", "hdf5_file", ".", "create_dataset", "(", "'encoded_images'", ",", "shape", "=", "(", "n_total", ",", ")", ",", "dtype", "=", "vlen_dtype", ")", "hdf5_file", ".", "create_dataset", "(", "'targets'", ",", "shape", "=", "(", "n_total", ",", "1", ")", ",", "dtype", "=", "numpy", ".", "int16", ")", "hdf5_file", ".", "create_dataset", "(", "'filenames'", ",", "shape", "=", "(", "n_total", ",", "1", ")", ",", "dtype", "=", "'S32'", ")" ]
Create datasets within a given HDF5 file. Parameters ---------- hdf5_file : :class:`h5py.File` instance HDF5 file handle to which to write. n_train : int The number of training set examples. n_valid : int The number of validation set examples. n_test : int The number of test set examples.
[ "Create", "datasets", "within", "a", "given", "HDF5", "file", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/ilsvrc2010.py#L179-L201
train
mila-iqia/fuel
fuel/converters/ilsvrc2010.py
process_train_set
def process_train_set(hdf5_file, train_archive, patch_archive, n_train, wnid_map, shuffle_seed=None): """Process the ILSVRC2010 training set. Parameters ---------- hdf5_file : :class:`h5py.File` instance HDF5 file handle to which to write. Assumes `features`, `targets` and `filenames` already exist and have first dimension larger than `n_train`. train_archive : str or file-like object Filename or file handle for the TAR archive of training images. patch_archive : str or file-like object Filename or file handle for the TAR archive of patch images. n_train : int The number of items in the training set. wnid_map : dict A dictionary mapping WordNet IDs to class indices. shuffle_seed : int or sequence, optional Seed for a NumPy random number generator that permutes the training set on disk. If `None`, no permutation is performed (this is the default). """ producer = partial(train_set_producer, train_archive=train_archive, patch_archive=patch_archive, wnid_map=wnid_map) consumer = partial(image_consumer, hdf5_file=hdf5_file, num_expected=n_train, shuffle_seed=shuffle_seed) producer_consumer(producer, consumer)
python
def process_train_set(hdf5_file, train_archive, patch_archive, n_train, wnid_map, shuffle_seed=None): """Process the ILSVRC2010 training set. Parameters ---------- hdf5_file : :class:`h5py.File` instance HDF5 file handle to which to write. Assumes `features`, `targets` and `filenames` already exist and have first dimension larger than `n_train`. train_archive : str or file-like object Filename or file handle for the TAR archive of training images. patch_archive : str or file-like object Filename or file handle for the TAR archive of patch images. n_train : int The number of items in the training set. wnid_map : dict A dictionary mapping WordNet IDs to class indices. shuffle_seed : int or sequence, optional Seed for a NumPy random number generator that permutes the training set on disk. If `None`, no permutation is performed (this is the default). """ producer = partial(train_set_producer, train_archive=train_archive, patch_archive=patch_archive, wnid_map=wnid_map) consumer = partial(image_consumer, hdf5_file=hdf5_file, num_expected=n_train, shuffle_seed=shuffle_seed) producer_consumer(producer, consumer)
[ "def", "process_train_set", "(", "hdf5_file", ",", "train_archive", ",", "patch_archive", ",", "n_train", ",", "wnid_map", ",", "shuffle_seed", "=", "None", ")", ":", "producer", "=", "partial", "(", "train_set_producer", ",", "train_archive", "=", "train_archive", ",", "patch_archive", "=", "patch_archive", ",", "wnid_map", "=", "wnid_map", ")", "consumer", "=", "partial", "(", "image_consumer", ",", "hdf5_file", "=", "hdf5_file", ",", "num_expected", "=", "n_train", ",", "shuffle_seed", "=", "shuffle_seed", ")", "producer_consumer", "(", "producer", ",", "consumer", ")" ]
Process the ILSVRC2010 training set. Parameters ---------- hdf5_file : :class:`h5py.File` instance HDF5 file handle to which to write. Assumes `features`, `targets` and `filenames` already exist and have first dimension larger than `n_train`. train_archive : str or file-like object Filename or file handle for the TAR archive of training images. patch_archive : str or file-like object Filename or file handle for the TAR archive of patch images. n_train : int The number of items in the training set. wnid_map : dict A dictionary mapping WordNet IDs to class indices. shuffle_seed : int or sequence, optional Seed for a NumPy random number generator that permutes the training set on disk. If `None`, no permutation is performed (this is the default).
[ "Process", "the", "ILSVRC2010", "training", "set", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/ilsvrc2010.py#L204-L232
train
mila-iqia/fuel
fuel/converters/ilsvrc2010.py
image_consumer
def image_consumer(socket, hdf5_file, num_expected, shuffle_seed=None, offset=0): """Fill an HDF5 file with incoming images from a socket. Parameters ---------- socket : :class:`zmq.Socket` PULL socket on which to receive images. hdf5_file : :class:`h5py.File` instance HDF5 file handle to which to write. Assumes `features`, `targets` and `filenames` already exist and have first dimension larger than `sum(images_per_class)`. num_expected : int The number of items we expect to be sent over the socket. shuffle_seed : int or sequence, optional Seed for a NumPy random number generator that permutes the images on disk. offset : int, optional The offset in the HDF5 datasets at which to start writing received examples. Defaults to 0. """ with progress_bar('images', maxval=num_expected) as pb: if shuffle_seed is None: index_gen = iter(xrange(num_expected)) else: rng = numpy.random.RandomState(shuffle_seed) index_gen = iter(rng.permutation(num_expected)) for i, num in enumerate(index_gen): image_filename, class_index = socket.recv_pyobj(zmq.SNDMORE) image_data = numpy.fromstring(socket.recv(), dtype='uint8') _write_to_hdf5(hdf5_file, num + offset, image_filename, image_data, class_index) pb.update(i + 1)
python
def image_consumer(socket, hdf5_file, num_expected, shuffle_seed=None, offset=0): """Fill an HDF5 file with incoming images from a socket. Parameters ---------- socket : :class:`zmq.Socket` PULL socket on which to receive images. hdf5_file : :class:`h5py.File` instance HDF5 file handle to which to write. Assumes `features`, `targets` and `filenames` already exist and have first dimension larger than `sum(images_per_class)`. num_expected : int The number of items we expect to be sent over the socket. shuffle_seed : int or sequence, optional Seed for a NumPy random number generator that permutes the images on disk. offset : int, optional The offset in the HDF5 datasets at which to start writing received examples. Defaults to 0. """ with progress_bar('images', maxval=num_expected) as pb: if shuffle_seed is None: index_gen = iter(xrange(num_expected)) else: rng = numpy.random.RandomState(shuffle_seed) index_gen = iter(rng.permutation(num_expected)) for i, num in enumerate(index_gen): image_filename, class_index = socket.recv_pyobj(zmq.SNDMORE) image_data = numpy.fromstring(socket.recv(), dtype='uint8') _write_to_hdf5(hdf5_file, num + offset, image_filename, image_data, class_index) pb.update(i + 1)
[ "def", "image_consumer", "(", "socket", ",", "hdf5_file", ",", "num_expected", ",", "shuffle_seed", "=", "None", ",", "offset", "=", "0", ")", ":", "with", "progress_bar", "(", "'images'", ",", "maxval", "=", "num_expected", ")", "as", "pb", ":", "if", "shuffle_seed", "is", "None", ":", "index_gen", "=", "iter", "(", "xrange", "(", "num_expected", ")", ")", "else", ":", "rng", "=", "numpy", ".", "random", ".", "RandomState", "(", "shuffle_seed", ")", "index_gen", "=", "iter", "(", "rng", ".", "permutation", "(", "num_expected", ")", ")", "for", "i", ",", "num", "in", "enumerate", "(", "index_gen", ")", ":", "image_filename", ",", "class_index", "=", "socket", ".", "recv_pyobj", "(", "zmq", ".", "SNDMORE", ")", "image_data", "=", "numpy", ".", "fromstring", "(", "socket", ".", "recv", "(", ")", ",", "dtype", "=", "'uint8'", ")", "_write_to_hdf5", "(", "hdf5_file", ",", "num", "+", "offset", ",", "image_filename", ",", "image_data", ",", "class_index", ")", "pb", ".", "update", "(", "i", "+", "1", ")" ]
Fill an HDF5 file with incoming images from a socket. Parameters ---------- socket : :class:`zmq.Socket` PULL socket on which to receive images. hdf5_file : :class:`h5py.File` instance HDF5 file handle to which to write. Assumes `features`, `targets` and `filenames` already exist and have first dimension larger than `sum(images_per_class)`. num_expected : int The number of items we expect to be sent over the socket. shuffle_seed : int or sequence, optional Seed for a NumPy random number generator that permutes the images on disk. offset : int, optional The offset in the HDF5 datasets at which to start writing received examples. Defaults to 0.
[ "Fill", "an", "HDF5", "file", "with", "incoming", "images", "from", "a", "socket", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/ilsvrc2010.py#L283-L316
train
mila-iqia/fuel
fuel/converters/ilsvrc2010.py
process_other_set
def process_other_set(hdf5_file, which_set, image_archive, patch_archive, groundtruth, offset): """Process the validation or test set. Parameters ---------- hdf5_file : :class:`h5py.File` instance HDF5 file handle to which to write. Assumes `features`, `targets` and `filenames` already exist and have first dimension larger than `sum(images_per_class)`. which_set : str Which set of images is being processed. One of 'train', 'valid', 'test'. Used for extracting the appropriate images from the patch archive. image_archive : str or file-like object The filename or file-handle for the TAR archive containing images. patch_archive : str or file-like object Filename or file handle for the TAR archive of patch images. groundtruth : iterable Iterable container containing scalar 0-based class index for each image, sorted by filename. offset : int The offset in the HDF5 datasets at which to start writing. """ producer = partial(other_set_producer, image_archive=image_archive, patch_archive=patch_archive, groundtruth=groundtruth, which_set=which_set) consumer = partial(image_consumer, hdf5_file=hdf5_file, num_expected=len(groundtruth), offset=offset) producer_consumer(producer, consumer)
python
def process_other_set(hdf5_file, which_set, image_archive, patch_archive, groundtruth, offset): """Process the validation or test set. Parameters ---------- hdf5_file : :class:`h5py.File` instance HDF5 file handle to which to write. Assumes `features`, `targets` and `filenames` already exist and have first dimension larger than `sum(images_per_class)`. which_set : str Which set of images is being processed. One of 'train', 'valid', 'test'. Used for extracting the appropriate images from the patch archive. image_archive : str or file-like object The filename or file-handle for the TAR archive containing images. patch_archive : str or file-like object Filename or file handle for the TAR archive of patch images. groundtruth : iterable Iterable container containing scalar 0-based class index for each image, sorted by filename. offset : int The offset in the HDF5 datasets at which to start writing. """ producer = partial(other_set_producer, image_archive=image_archive, patch_archive=patch_archive, groundtruth=groundtruth, which_set=which_set) consumer = partial(image_consumer, hdf5_file=hdf5_file, num_expected=len(groundtruth), offset=offset) producer_consumer(producer, consumer)
[ "def", "process_other_set", "(", "hdf5_file", ",", "which_set", ",", "image_archive", ",", "patch_archive", ",", "groundtruth", ",", "offset", ")", ":", "producer", "=", "partial", "(", "other_set_producer", ",", "image_archive", "=", "image_archive", ",", "patch_archive", "=", "patch_archive", ",", "groundtruth", "=", "groundtruth", ",", "which_set", "=", "which_set", ")", "consumer", "=", "partial", "(", "image_consumer", ",", "hdf5_file", "=", "hdf5_file", ",", "num_expected", "=", "len", "(", "groundtruth", ")", ",", "offset", "=", "offset", ")", "producer_consumer", "(", "producer", ",", "consumer", ")" ]
Process the validation or test set. Parameters ---------- hdf5_file : :class:`h5py.File` instance HDF5 file handle to which to write. Assumes `features`, `targets` and `filenames` already exist and have first dimension larger than `sum(images_per_class)`. which_set : str Which set of images is being processed. One of 'train', 'valid', 'test'. Used for extracting the appropriate images from the patch archive. image_archive : str or file-like object The filename or file-handle for the TAR archive containing images. patch_archive : str or file-like object Filename or file handle for the TAR archive of patch images. groundtruth : iterable Iterable container containing scalar 0-based class index for each image, sorted by filename. offset : int The offset in the HDF5 datasets at which to start writing.
[ "Process", "the", "validation", "or", "test", "set", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/ilsvrc2010.py#L319-L349
train
mila-iqia/fuel
fuel/converters/ilsvrc2010.py
load_from_tar_or_patch
def load_from_tar_or_patch(tar, image_filename, patch_images): """Do everything necessary to process an image inside a TAR. Parameters ---------- tar : `TarFile` instance The tar from which to read `image_filename`. image_filename : str Fully-qualified path inside of `tar` from which to read an image file. patch_images : dict A dictionary containing filenames (without path) of replacements to be substituted in place of the version of the same file found in `tar`. Returns ------- image_data : bytes The JPEG bytes representing either the image from the TAR archive or its replacement from the patch dictionary. patched : bool True if the image was retrieved from the patch dictionary. False if it was retrieved from the TAR file. """ patched = True image_bytes = patch_images.get(os.path.basename(image_filename), None) if image_bytes is None: patched = False try: image_bytes = tar.extractfile(image_filename).read() numpy.array(Image.open(io.BytesIO(image_bytes))) except (IOError, OSError): with gzip.GzipFile(fileobj=tar.extractfile(image_filename)) as gz: image_bytes = gz.read() numpy.array(Image.open(io.BytesIO(image_bytes))) return image_bytes, patched
python
def load_from_tar_or_patch(tar, image_filename, patch_images): """Do everything necessary to process an image inside a TAR. Parameters ---------- tar : `TarFile` instance The tar from which to read `image_filename`. image_filename : str Fully-qualified path inside of `tar` from which to read an image file. patch_images : dict A dictionary containing filenames (without path) of replacements to be substituted in place of the version of the same file found in `tar`. Returns ------- image_data : bytes The JPEG bytes representing either the image from the TAR archive or its replacement from the patch dictionary. patched : bool True if the image was retrieved from the patch dictionary. False if it was retrieved from the TAR file. """ patched = True image_bytes = patch_images.get(os.path.basename(image_filename), None) if image_bytes is None: patched = False try: image_bytes = tar.extractfile(image_filename).read() numpy.array(Image.open(io.BytesIO(image_bytes))) except (IOError, OSError): with gzip.GzipFile(fileobj=tar.extractfile(image_filename)) as gz: image_bytes = gz.read() numpy.array(Image.open(io.BytesIO(image_bytes))) return image_bytes, patched
[ "def", "load_from_tar_or_patch", "(", "tar", ",", "image_filename", ",", "patch_images", ")", ":", "patched", "=", "True", "image_bytes", "=", "patch_images", ".", "get", "(", "os", ".", "path", ".", "basename", "(", "image_filename", ")", ",", "None", ")", "if", "image_bytes", "is", "None", ":", "patched", "=", "False", "try", ":", "image_bytes", "=", "tar", ".", "extractfile", "(", "image_filename", ")", ".", "read", "(", ")", "numpy", ".", "array", "(", "Image", ".", "open", "(", "io", ".", "BytesIO", "(", "image_bytes", ")", ")", ")", "except", "(", "IOError", ",", "OSError", ")", ":", "with", "gzip", ".", "GzipFile", "(", "fileobj", "=", "tar", ".", "extractfile", "(", "image_filename", ")", ")", "as", "gz", ":", "image_bytes", "=", "gz", ".", "read", "(", ")", "numpy", ".", "array", "(", "Image", ".", "open", "(", "io", ".", "BytesIO", "(", "image_bytes", ")", ")", ")", "return", "image_bytes", ",", "patched" ]
Do everything necessary to process an image inside a TAR. Parameters ---------- tar : `TarFile` instance The tar from which to read `image_filename`. image_filename : str Fully-qualified path inside of `tar` from which to read an image file. patch_images : dict A dictionary containing filenames (without path) of replacements to be substituted in place of the version of the same file found in `tar`. Returns ------- image_data : bytes The JPEG bytes representing either the image from the TAR archive or its replacement from the patch dictionary. patched : bool True if the image was retrieved from the patch dictionary. False if it was retrieved from the TAR file.
[ "Do", "everything", "necessary", "to", "process", "an", "image", "inside", "a", "TAR", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/ilsvrc2010.py#L390-L426
train
mila-iqia/fuel
fuel/converters/ilsvrc2010.py
read_devkit
def read_devkit(f): """Read relevant information from the development kit archive. Parameters ---------- f : str or file-like object The filename or file-handle for the gzipped TAR archive containing the ILSVRC2010 development kit. Returns ------- synsets : ndarray, 1-dimensional, compound dtype See :func:`read_metadata_mat_file` for details. cost_matrix : ndarray, 2-dimensional, uint8 See :func:`read_metadata_mat_file` for details. raw_valid_groundtruth : ndarray, 1-dimensional, int16 The labels for the ILSVRC2010 validation set, distributed with the development kit code. """ with tar_open(f) as tar: # Metadata table containing class hierarchy, textual descriptions, etc. meta_mat = tar.extractfile(DEVKIT_META_PATH) synsets, cost_matrix = read_metadata_mat_file(meta_mat) # Raw validation data groundtruth, ILSVRC2010 IDs. Confusingly # distributed inside the development kit archive. raw_valid_groundtruth = numpy.loadtxt(tar.extractfile( DEVKIT_VALID_GROUNDTRUTH_PATH), dtype=numpy.int16) return synsets, cost_matrix, raw_valid_groundtruth
python
def read_devkit(f): """Read relevant information from the development kit archive. Parameters ---------- f : str or file-like object The filename or file-handle for the gzipped TAR archive containing the ILSVRC2010 development kit. Returns ------- synsets : ndarray, 1-dimensional, compound dtype See :func:`read_metadata_mat_file` for details. cost_matrix : ndarray, 2-dimensional, uint8 See :func:`read_metadata_mat_file` for details. raw_valid_groundtruth : ndarray, 1-dimensional, int16 The labels for the ILSVRC2010 validation set, distributed with the development kit code. """ with tar_open(f) as tar: # Metadata table containing class hierarchy, textual descriptions, etc. meta_mat = tar.extractfile(DEVKIT_META_PATH) synsets, cost_matrix = read_metadata_mat_file(meta_mat) # Raw validation data groundtruth, ILSVRC2010 IDs. Confusingly # distributed inside the development kit archive. raw_valid_groundtruth = numpy.loadtxt(tar.extractfile( DEVKIT_VALID_GROUNDTRUTH_PATH), dtype=numpy.int16) return synsets, cost_matrix, raw_valid_groundtruth
[ "def", "read_devkit", "(", "f", ")", ":", "with", "tar_open", "(", "f", ")", "as", "tar", ":", "# Metadata table containing class hierarchy, textual descriptions, etc.", "meta_mat", "=", "tar", ".", "extractfile", "(", "DEVKIT_META_PATH", ")", "synsets", ",", "cost_matrix", "=", "read_metadata_mat_file", "(", "meta_mat", ")", "# Raw validation data groundtruth, ILSVRC2010 IDs. Confusingly", "# distributed inside the development kit archive.", "raw_valid_groundtruth", "=", "numpy", ".", "loadtxt", "(", "tar", ".", "extractfile", "(", "DEVKIT_VALID_GROUNDTRUTH_PATH", ")", ",", "dtype", "=", "numpy", ".", "int16", ")", "return", "synsets", ",", "cost_matrix", ",", "raw_valid_groundtruth" ]
Read relevant information from the development kit archive. Parameters ---------- f : str or file-like object The filename or file-handle for the gzipped TAR archive containing the ILSVRC2010 development kit. Returns ------- synsets : ndarray, 1-dimensional, compound dtype See :func:`read_metadata_mat_file` for details. cost_matrix : ndarray, 2-dimensional, uint8 See :func:`read_metadata_mat_file` for details. raw_valid_groundtruth : ndarray, 1-dimensional, int16 The labels for the ILSVRC2010 validation set, distributed with the development kit code.
[ "Read", "relevant", "information", "from", "the", "development", "kit", "archive", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/ilsvrc2010.py#L429-L458
train
mila-iqia/fuel
fuel/converters/ilsvrc2010.py
extract_patch_images
def extract_patch_images(f, which_set): """Extracts a dict of the "patch images" for ILSVRC2010. Parameters ---------- f : str or file-like object The filename or file-handle to the patch images TAR file. which_set : str Which set of images to extract. One of 'train', 'valid', 'test'. Returns ------- dict A dictionary contains a mapping of filenames (without path) to a bytes object containing the replacement image. Notes ----- Certain images in the distributed archives are blank, or display an "image not available" banner. A separate TAR file of "patch images" is distributed with the corrected versions of these. It is this archive that this function is intended to read. """ if which_set not in ('train', 'valid', 'test'): raise ValueError('which_set must be one of train, valid, or test') which_set = 'val' if which_set == 'valid' else which_set patch_images = {} with tar_open(f) as tar: for info_obj in tar: if not info_obj.name.endswith('.JPEG'): continue # Pretty sure that '/' is used for tarfile regardless of # os.path.sep, but I officially don't care about Windows. tokens = info_obj.name.split('/') file_which_set = tokens[-2] if file_which_set != which_set: continue filename = tokens[-1] patch_images[filename] = tar.extractfile(info_obj.name).read() return patch_images
python
def extract_patch_images(f, which_set): """Extracts a dict of the "patch images" for ILSVRC2010. Parameters ---------- f : str or file-like object The filename or file-handle to the patch images TAR file. which_set : str Which set of images to extract. One of 'train', 'valid', 'test'. Returns ------- dict A dictionary contains a mapping of filenames (without path) to a bytes object containing the replacement image. Notes ----- Certain images in the distributed archives are blank, or display an "image not available" banner. A separate TAR file of "patch images" is distributed with the corrected versions of these. It is this archive that this function is intended to read. """ if which_set not in ('train', 'valid', 'test'): raise ValueError('which_set must be one of train, valid, or test') which_set = 'val' if which_set == 'valid' else which_set patch_images = {} with tar_open(f) as tar: for info_obj in tar: if not info_obj.name.endswith('.JPEG'): continue # Pretty sure that '/' is used for tarfile regardless of # os.path.sep, but I officially don't care about Windows. tokens = info_obj.name.split('/') file_which_set = tokens[-2] if file_which_set != which_set: continue filename = tokens[-1] patch_images[filename] = tar.extractfile(info_obj.name).read() return patch_images
[ "def", "extract_patch_images", "(", "f", ",", "which_set", ")", ":", "if", "which_set", "not", "in", "(", "'train'", ",", "'valid'", ",", "'test'", ")", ":", "raise", "ValueError", "(", "'which_set must be one of train, valid, or test'", ")", "which_set", "=", "'val'", "if", "which_set", "==", "'valid'", "else", "which_set", "patch_images", "=", "{", "}", "with", "tar_open", "(", "f", ")", "as", "tar", ":", "for", "info_obj", "in", "tar", ":", "if", "not", "info_obj", ".", "name", ".", "endswith", "(", "'.JPEG'", ")", ":", "continue", "# Pretty sure that '/' is used for tarfile regardless of", "# os.path.sep, but I officially don't care about Windows.", "tokens", "=", "info_obj", ".", "name", ".", "split", "(", "'/'", ")", "file_which_set", "=", "tokens", "[", "-", "2", "]", "if", "file_which_set", "!=", "which_set", ":", "continue", "filename", "=", "tokens", "[", "-", "1", "]", "patch_images", "[", "filename", "]", "=", "tar", ".", "extractfile", "(", "info_obj", ".", "name", ")", ".", "read", "(", ")", "return", "patch_images" ]
Extracts a dict of the "patch images" for ILSVRC2010. Parameters ---------- f : str or file-like object The filename or file-handle to the patch images TAR file. which_set : str Which set of images to extract. One of 'train', 'valid', 'test'. Returns ------- dict A dictionary contains a mapping of filenames (without path) to a bytes object containing the replacement image. Notes ----- Certain images in the distributed archives are blank, or display an "image not available" banner. A separate TAR file of "patch images" is distributed with the corrected versions of these. It is this archive that this function is intended to read.
[ "Extracts", "a", "dict", "of", "the", "patch", "images", "for", "ILSVRC2010", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/ilsvrc2010.py#L533-L573
train
mila-iqia/fuel
fuel/converters/cifar10.py
convert_cifar10
def convert_cifar10(directory, output_directory, output_filename='cifar10.hdf5'): """Converts the CIFAR-10 dataset to HDF5. Converts the CIFAR-10 dataset to an HDF5 dataset compatible with :class:`fuel.datasets.CIFAR10`. The converted dataset is saved as 'cifar10.hdf5'. It assumes the existence of the following file: * `cifar-10-python.tar.gz` Parameters ---------- directory : str Directory in which input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to 'cifar10.hdf5'. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset. """ output_path = os.path.join(output_directory, output_filename) h5file = h5py.File(output_path, mode='w') input_file = os.path.join(directory, DISTRIBUTION_FILE) tar_file = tarfile.open(input_file, 'r:gz') train_batches = [] for batch in range(1, 6): file = tar_file.extractfile( 'cifar-10-batches-py/data_batch_%d' % batch) try: if six.PY3: array = cPickle.load(file, encoding='latin1') else: array = cPickle.load(file) train_batches.append(array) finally: file.close() train_features = numpy.concatenate( [batch['data'].reshape(batch['data'].shape[0], 3, 32, 32) for batch in train_batches]) train_labels = numpy.concatenate( [numpy.array(batch['labels'], dtype=numpy.uint8) for batch in train_batches]) train_labels = numpy.expand_dims(train_labels, 1) file = tar_file.extractfile('cifar-10-batches-py/test_batch') try: if six.PY3: test = cPickle.load(file, encoding='latin1') else: test = cPickle.load(file) finally: file.close() test_features = test['data'].reshape(test['data'].shape[0], 3, 32, 32) test_labels = numpy.array(test['labels'], dtype=numpy.uint8) test_labels = numpy.expand_dims(test_labels, 1) data = (('train', 'features', train_features), ('train', 'targets', train_labels), ('test', 'features', test_features), ('test', 'targets', test_labels)) fill_hdf5_file(h5file, data) h5file['features'].dims[0].label = 'batch' h5file['features'].dims[1].label = 'channel' h5file['features'].dims[2].label = 'height' h5file['features'].dims[3].label = 'width' h5file['targets'].dims[0].label = 'batch' h5file['targets'].dims[1].label = 'index' h5file.flush() h5file.close() return (output_path,)
python
def convert_cifar10(directory, output_directory, output_filename='cifar10.hdf5'): """Converts the CIFAR-10 dataset to HDF5. Converts the CIFAR-10 dataset to an HDF5 dataset compatible with :class:`fuel.datasets.CIFAR10`. The converted dataset is saved as 'cifar10.hdf5'. It assumes the existence of the following file: * `cifar-10-python.tar.gz` Parameters ---------- directory : str Directory in which input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to 'cifar10.hdf5'. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset. """ output_path = os.path.join(output_directory, output_filename) h5file = h5py.File(output_path, mode='w') input_file = os.path.join(directory, DISTRIBUTION_FILE) tar_file = tarfile.open(input_file, 'r:gz') train_batches = [] for batch in range(1, 6): file = tar_file.extractfile( 'cifar-10-batches-py/data_batch_%d' % batch) try: if six.PY3: array = cPickle.load(file, encoding='latin1') else: array = cPickle.load(file) train_batches.append(array) finally: file.close() train_features = numpy.concatenate( [batch['data'].reshape(batch['data'].shape[0], 3, 32, 32) for batch in train_batches]) train_labels = numpy.concatenate( [numpy.array(batch['labels'], dtype=numpy.uint8) for batch in train_batches]) train_labels = numpy.expand_dims(train_labels, 1) file = tar_file.extractfile('cifar-10-batches-py/test_batch') try: if six.PY3: test = cPickle.load(file, encoding='latin1') else: test = cPickle.load(file) finally: file.close() test_features = test['data'].reshape(test['data'].shape[0], 3, 32, 32) test_labels = numpy.array(test['labels'], dtype=numpy.uint8) test_labels = numpy.expand_dims(test_labels, 1) data = (('train', 'features', train_features), ('train', 'targets', train_labels), ('test', 'features', test_features), ('test', 'targets', test_labels)) fill_hdf5_file(h5file, data) h5file['features'].dims[0].label = 'batch' h5file['features'].dims[1].label = 'channel' h5file['features'].dims[2].label = 'height' h5file['features'].dims[3].label = 'width' h5file['targets'].dims[0].label = 'batch' h5file['targets'].dims[1].label = 'index' h5file.flush() h5file.close() return (output_path,)
[ "def", "convert_cifar10", "(", "directory", ",", "output_directory", ",", "output_filename", "=", "'cifar10.hdf5'", ")", ":", "output_path", "=", "os", ".", "path", ".", "join", "(", "output_directory", ",", "output_filename", ")", "h5file", "=", "h5py", ".", "File", "(", "output_path", ",", "mode", "=", "'w'", ")", "input_file", "=", "os", ".", "path", ".", "join", "(", "directory", ",", "DISTRIBUTION_FILE", ")", "tar_file", "=", "tarfile", ".", "open", "(", "input_file", ",", "'r:gz'", ")", "train_batches", "=", "[", "]", "for", "batch", "in", "range", "(", "1", ",", "6", ")", ":", "file", "=", "tar_file", ".", "extractfile", "(", "'cifar-10-batches-py/data_batch_%d'", "%", "batch", ")", "try", ":", "if", "six", ".", "PY3", ":", "array", "=", "cPickle", ".", "load", "(", "file", ",", "encoding", "=", "'latin1'", ")", "else", ":", "array", "=", "cPickle", ".", "load", "(", "file", ")", "train_batches", ".", "append", "(", "array", ")", "finally", ":", "file", ".", "close", "(", ")", "train_features", "=", "numpy", ".", "concatenate", "(", "[", "batch", "[", "'data'", "]", ".", "reshape", "(", "batch", "[", "'data'", "]", ".", "shape", "[", "0", "]", ",", "3", ",", "32", ",", "32", ")", "for", "batch", "in", "train_batches", "]", ")", "train_labels", "=", "numpy", ".", "concatenate", "(", "[", "numpy", ".", "array", "(", "batch", "[", "'labels'", "]", ",", "dtype", "=", "numpy", ".", "uint8", ")", "for", "batch", "in", "train_batches", "]", ")", "train_labels", "=", "numpy", ".", "expand_dims", "(", "train_labels", ",", "1", ")", "file", "=", "tar_file", ".", "extractfile", "(", "'cifar-10-batches-py/test_batch'", ")", "try", ":", "if", "six", ".", "PY3", ":", "test", "=", "cPickle", ".", "load", "(", "file", ",", "encoding", "=", "'latin1'", ")", "else", ":", "test", "=", "cPickle", ".", "load", "(", "file", ")", "finally", ":", "file", ".", "close", "(", ")", "test_features", "=", "test", "[", "'data'", "]", ".", "reshape", "(", "test", "[", "'data'", "]", ".", "shape", "[", "0", "]", ",", "3", ",", "32", ",", "32", ")", "test_labels", "=", "numpy", ".", "array", "(", "test", "[", "'labels'", "]", ",", "dtype", "=", "numpy", ".", "uint8", ")", "test_labels", "=", "numpy", ".", "expand_dims", "(", "test_labels", ",", "1", ")", "data", "=", "(", "(", "'train'", ",", "'features'", ",", "train_features", ")", ",", "(", "'train'", ",", "'targets'", ",", "train_labels", ")", ",", "(", "'test'", ",", "'features'", ",", "test_features", ")", ",", "(", "'test'", ",", "'targets'", ",", "test_labels", ")", ")", "fill_hdf5_file", "(", "h5file", ",", "data", ")", "h5file", "[", "'features'", "]", ".", "dims", "[", "0", "]", ".", "label", "=", "'batch'", "h5file", "[", "'features'", "]", ".", "dims", "[", "1", "]", ".", "label", "=", "'channel'", "h5file", "[", "'features'", "]", ".", "dims", "[", "2", "]", ".", "label", "=", "'height'", "h5file", "[", "'features'", "]", ".", "dims", "[", "3", "]", ".", "label", "=", "'width'", "h5file", "[", "'targets'", "]", ".", "dims", "[", "0", "]", ".", "label", "=", "'batch'", "h5file", "[", "'targets'", "]", ".", "dims", "[", "1", "]", ".", "label", "=", "'index'", "h5file", ".", "flush", "(", ")", "h5file", ".", "close", "(", ")", "return", "(", "output_path", ",", ")" ]
Converts the CIFAR-10 dataset to HDF5. Converts the CIFAR-10 dataset to an HDF5 dataset compatible with :class:`fuel.datasets.CIFAR10`. The converted dataset is saved as 'cifar10.hdf5'. It assumes the existence of the following file: * `cifar-10-python.tar.gz` Parameters ---------- directory : str Directory in which input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to 'cifar10.hdf5'. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset.
[ "Converts", "the", "CIFAR", "-", "10", "dataset", "to", "HDF5", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/cifar10.py#L15-L97
train
mila-iqia/fuel
fuel/converters/base.py
check_exists
def check_exists(required_files): """Decorator that checks if required files exist before running. Parameters ---------- required_files : list of str A list of strings indicating the filenames of regular files (not directories) that should be found in the input directory (which is the first argument to the wrapped function). Returns ------- wrapper : function A function that takes a function and returns a wrapped function. The function returned by `wrapper` will include input file existence verification. Notes ----- Assumes that the directory in which to find the input files is provided as the first argument, with the argument name `directory`. """ def function_wrapper(f): @wraps(f) def wrapped(directory, *args, **kwargs): missing = [] for filename in required_files: if not os.path.isfile(os.path.join(directory, filename)): missing.append(filename) if len(missing) > 0: raise MissingInputFiles('Required files missing', missing) return f(directory, *args, **kwargs) return wrapped return function_wrapper
python
def check_exists(required_files): """Decorator that checks if required files exist before running. Parameters ---------- required_files : list of str A list of strings indicating the filenames of regular files (not directories) that should be found in the input directory (which is the first argument to the wrapped function). Returns ------- wrapper : function A function that takes a function and returns a wrapped function. The function returned by `wrapper` will include input file existence verification. Notes ----- Assumes that the directory in which to find the input files is provided as the first argument, with the argument name `directory`. """ def function_wrapper(f): @wraps(f) def wrapped(directory, *args, **kwargs): missing = [] for filename in required_files: if not os.path.isfile(os.path.join(directory, filename)): missing.append(filename) if len(missing) > 0: raise MissingInputFiles('Required files missing', missing) return f(directory, *args, **kwargs) return wrapped return function_wrapper
[ "def", "check_exists", "(", "required_files", ")", ":", "def", "function_wrapper", "(", "f", ")", ":", "@", "wraps", "(", "f", ")", "def", "wrapped", "(", "directory", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "missing", "=", "[", "]", "for", "filename", "in", "required_files", ":", "if", "not", "os", ".", "path", ".", "isfile", "(", "os", ".", "path", ".", "join", "(", "directory", ",", "filename", ")", ")", ":", "missing", ".", "append", "(", "filename", ")", "if", "len", "(", "missing", ")", ">", "0", ":", "raise", "MissingInputFiles", "(", "'Required files missing'", ",", "missing", ")", "return", "f", "(", "directory", ",", "*", "args", ",", "*", "*", "kwargs", ")", "return", "wrapped", "return", "function_wrapper" ]
Decorator that checks if required files exist before running. Parameters ---------- required_files : list of str A list of strings indicating the filenames of regular files (not directories) that should be found in the input directory (which is the first argument to the wrapped function). Returns ------- wrapper : function A function that takes a function and returns a wrapped function. The function returned by `wrapper` will include input file existence verification. Notes ----- Assumes that the directory in which to find the input files is provided as the first argument, with the argument name `directory`.
[ "Decorator", "that", "checks", "if", "required", "files", "exist", "before", "running", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/base.py#L13-L47
train
mila-iqia/fuel
fuel/converters/base.py
fill_hdf5_file
def fill_hdf5_file(h5file, data): """Fills an HDF5 file in a H5PYDataset-compatible manner. Parameters ---------- h5file : :class:`h5py.File` File handle for an HDF5 file. data : tuple of tuple One element per split/source pair. Each element consists of a tuple of (split_name, source_name, data_array, comment), where * 'split_name' is a string identifier for the split name * 'source_name' is a string identifier for the source name * 'data_array' is a :class:`numpy.ndarray` containing the data for this split/source pair * 'comment' is a comment string for the split/source pair The 'comment' element can optionally be omitted. """ # Check that all sources for a split have the same length split_names = set(split_tuple[0] for split_tuple in data) for name in split_names: lengths = [len(split_tuple[2]) for split_tuple in data if split_tuple[0] == name] if not all(le == lengths[0] for le in lengths): raise ValueError("split '{}' has sources that ".format(name) + "vary in length") # Initialize split dictionary split_dict = dict([(split_name, {}) for split_name in split_names]) # Compute total source lengths and check that splits have the same dtype # across a source source_names = set(split_tuple[1] for split_tuple in data) for name in source_names: splits = [s for s in data if s[1] == name] indices = numpy.cumsum([0] + [len(s[2]) for s in splits]) if not all(s[2].dtype == splits[0][2].dtype for s in splits): raise ValueError("source '{}' has splits that ".format(name) + "vary in dtype") if not all(s[2].shape[1:] == splits[0][2].shape[1:] for s in splits): raise ValueError("source '{}' has splits that ".format(name) + "vary in shapes") dataset = h5file.create_dataset( name, (sum(len(s[2]) for s in splits),) + splits[0][2].shape[1:], dtype=splits[0][2].dtype) dataset[...] = numpy.concatenate([s[2] for s in splits], axis=0) for i, j, s in zip(indices[:-1], indices[1:], splits): if len(s) == 4: split_dict[s[0]][name] = (i, j, None, s[3]) else: split_dict[s[0]][name] = (i, j) h5file.attrs['split'] = H5PYDataset.create_split_array(split_dict)
python
def fill_hdf5_file(h5file, data): """Fills an HDF5 file in a H5PYDataset-compatible manner. Parameters ---------- h5file : :class:`h5py.File` File handle for an HDF5 file. data : tuple of tuple One element per split/source pair. Each element consists of a tuple of (split_name, source_name, data_array, comment), where * 'split_name' is a string identifier for the split name * 'source_name' is a string identifier for the source name * 'data_array' is a :class:`numpy.ndarray` containing the data for this split/source pair * 'comment' is a comment string for the split/source pair The 'comment' element can optionally be omitted. """ # Check that all sources for a split have the same length split_names = set(split_tuple[0] for split_tuple in data) for name in split_names: lengths = [len(split_tuple[2]) for split_tuple in data if split_tuple[0] == name] if not all(le == lengths[0] for le in lengths): raise ValueError("split '{}' has sources that ".format(name) + "vary in length") # Initialize split dictionary split_dict = dict([(split_name, {}) for split_name in split_names]) # Compute total source lengths and check that splits have the same dtype # across a source source_names = set(split_tuple[1] for split_tuple in data) for name in source_names: splits = [s for s in data if s[1] == name] indices = numpy.cumsum([0] + [len(s[2]) for s in splits]) if not all(s[2].dtype == splits[0][2].dtype for s in splits): raise ValueError("source '{}' has splits that ".format(name) + "vary in dtype") if not all(s[2].shape[1:] == splits[0][2].shape[1:] for s in splits): raise ValueError("source '{}' has splits that ".format(name) + "vary in shapes") dataset = h5file.create_dataset( name, (sum(len(s[2]) for s in splits),) + splits[0][2].shape[1:], dtype=splits[0][2].dtype) dataset[...] = numpy.concatenate([s[2] for s in splits], axis=0) for i, j, s in zip(indices[:-1], indices[1:], splits): if len(s) == 4: split_dict[s[0]][name] = (i, j, None, s[3]) else: split_dict[s[0]][name] = (i, j) h5file.attrs['split'] = H5PYDataset.create_split_array(split_dict)
[ "def", "fill_hdf5_file", "(", "h5file", ",", "data", ")", ":", "# Check that all sources for a split have the same length", "split_names", "=", "set", "(", "split_tuple", "[", "0", "]", "for", "split_tuple", "in", "data", ")", "for", "name", "in", "split_names", ":", "lengths", "=", "[", "len", "(", "split_tuple", "[", "2", "]", ")", "for", "split_tuple", "in", "data", "if", "split_tuple", "[", "0", "]", "==", "name", "]", "if", "not", "all", "(", "le", "==", "lengths", "[", "0", "]", "for", "le", "in", "lengths", ")", ":", "raise", "ValueError", "(", "\"split '{}' has sources that \"", ".", "format", "(", "name", ")", "+", "\"vary in length\"", ")", "# Initialize split dictionary", "split_dict", "=", "dict", "(", "[", "(", "split_name", ",", "{", "}", ")", "for", "split_name", "in", "split_names", "]", ")", "# Compute total source lengths and check that splits have the same dtype", "# across a source", "source_names", "=", "set", "(", "split_tuple", "[", "1", "]", "for", "split_tuple", "in", "data", ")", "for", "name", "in", "source_names", ":", "splits", "=", "[", "s", "for", "s", "in", "data", "if", "s", "[", "1", "]", "==", "name", "]", "indices", "=", "numpy", ".", "cumsum", "(", "[", "0", "]", "+", "[", "len", "(", "s", "[", "2", "]", ")", "for", "s", "in", "splits", "]", ")", "if", "not", "all", "(", "s", "[", "2", "]", ".", "dtype", "==", "splits", "[", "0", "]", "[", "2", "]", ".", "dtype", "for", "s", "in", "splits", ")", ":", "raise", "ValueError", "(", "\"source '{}' has splits that \"", ".", "format", "(", "name", ")", "+", "\"vary in dtype\"", ")", "if", "not", "all", "(", "s", "[", "2", "]", ".", "shape", "[", "1", ":", "]", "==", "splits", "[", "0", "]", "[", "2", "]", ".", "shape", "[", "1", ":", "]", "for", "s", "in", "splits", ")", ":", "raise", "ValueError", "(", "\"source '{}' has splits that \"", ".", "format", "(", "name", ")", "+", "\"vary in shapes\"", ")", "dataset", "=", "h5file", ".", "create_dataset", "(", "name", ",", "(", "sum", "(", "len", "(", "s", "[", "2", "]", ")", "for", "s", "in", "splits", ")", ",", ")", "+", "splits", "[", "0", "]", "[", "2", "]", ".", "shape", "[", "1", ":", "]", ",", "dtype", "=", "splits", "[", "0", "]", "[", "2", "]", ".", "dtype", ")", "dataset", "[", "...", "]", "=", "numpy", ".", "concatenate", "(", "[", "s", "[", "2", "]", "for", "s", "in", "splits", "]", ",", "axis", "=", "0", ")", "for", "i", ",", "j", ",", "s", "in", "zip", "(", "indices", "[", ":", "-", "1", "]", ",", "indices", "[", "1", ":", "]", ",", "splits", ")", ":", "if", "len", "(", "s", ")", "==", "4", ":", "split_dict", "[", "s", "[", "0", "]", "]", "[", "name", "]", "=", "(", "i", ",", "j", ",", "None", ",", "s", "[", "3", "]", ")", "else", ":", "split_dict", "[", "s", "[", "0", "]", "]", "[", "name", "]", "=", "(", "i", ",", "j", ")", "h5file", ".", "attrs", "[", "'split'", "]", "=", "H5PYDataset", ".", "create_split_array", "(", "split_dict", ")" ]
Fills an HDF5 file in a H5PYDataset-compatible manner. Parameters ---------- h5file : :class:`h5py.File` File handle for an HDF5 file. data : tuple of tuple One element per split/source pair. Each element consists of a tuple of (split_name, source_name, data_array, comment), where * 'split_name' is a string identifier for the split name * 'source_name' is a string identifier for the source name * 'data_array' is a :class:`numpy.ndarray` containing the data for this split/source pair * 'comment' is a comment string for the split/source pair The 'comment' element can optionally be omitted.
[ "Fills", "an", "HDF5", "file", "in", "a", "H5PYDataset", "-", "compatible", "manner", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/base.py#L50-L103
train
mila-iqia/fuel
fuel/converters/base.py
progress_bar
def progress_bar(name, maxval, prefix='Converting'): """Manages a progress bar for a conversion. Parameters ---------- name : str Name of the file being converted. maxval : int Total number of steps for the conversion. """ widgets = ['{} {}: '.format(prefix, name), Percentage(), ' ', Bar(marker='=', left='[', right=']'), ' ', ETA()] bar = ProgressBar(widgets=widgets, max_value=maxval, fd=sys.stdout).start() try: yield bar finally: bar.update(maxval) bar.finish()
python
def progress_bar(name, maxval, prefix='Converting'): """Manages a progress bar for a conversion. Parameters ---------- name : str Name of the file being converted. maxval : int Total number of steps for the conversion. """ widgets = ['{} {}: '.format(prefix, name), Percentage(), ' ', Bar(marker='=', left='[', right=']'), ' ', ETA()] bar = ProgressBar(widgets=widgets, max_value=maxval, fd=sys.stdout).start() try: yield bar finally: bar.update(maxval) bar.finish()
[ "def", "progress_bar", "(", "name", ",", "maxval", ",", "prefix", "=", "'Converting'", ")", ":", "widgets", "=", "[", "'{} {}: '", ".", "format", "(", "prefix", ",", "name", ")", ",", "Percentage", "(", ")", ",", "' '", ",", "Bar", "(", "marker", "=", "'='", ",", "left", "=", "'['", ",", "right", "=", "']'", ")", ",", "' '", ",", "ETA", "(", ")", "]", "bar", "=", "ProgressBar", "(", "widgets", "=", "widgets", ",", "max_value", "=", "maxval", ",", "fd", "=", "sys", ".", "stdout", ")", ".", "start", "(", ")", "try", ":", "yield", "bar", "finally", ":", "bar", ".", "update", "(", "maxval", ")", "bar", ".", "finish", "(", ")" ]
Manages a progress bar for a conversion. Parameters ---------- name : str Name of the file being converted. maxval : int Total number of steps for the conversion.
[ "Manages", "a", "progress", "bar", "for", "a", "conversion", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/base.py#L107-L125
train
mila-iqia/fuel
fuel/converters/iris.py
convert_iris
def convert_iris(directory, output_directory, output_filename='iris.hdf5'): """Convert the Iris dataset to HDF5. Converts the Iris dataset to an HDF5 dataset compatible with :class:`fuel.datasets.Iris`. The converted dataset is saved as 'iris.hdf5'. This method assumes the existence of the file `iris.data`. Parameters ---------- directory : str Directory in which input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to `None`, in which case a name based on `dtype` will be used. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset. """ classes = {b'Iris-setosa': 0, b'Iris-versicolor': 1, b'Iris-virginica': 2} data = numpy.loadtxt( os.path.join(directory, 'iris.data'), converters={4: lambda x: classes[x]}, delimiter=',') features = data[:, :-1].astype('float32') targets = data[:, -1].astype('uint8').reshape((-1, 1)) data = (('all', 'features', features), ('all', 'targets', targets)) output_path = os.path.join(output_directory, output_filename) h5file = h5py.File(output_path, mode='w') fill_hdf5_file(h5file, data) h5file['features'].dims[0].label = 'batch' h5file['features'].dims[1].label = 'feature' h5file['targets'].dims[0].label = 'batch' h5file['targets'].dims[1].label = 'index' h5file.flush() h5file.close() return (output_path,)
python
def convert_iris(directory, output_directory, output_filename='iris.hdf5'): """Convert the Iris dataset to HDF5. Converts the Iris dataset to an HDF5 dataset compatible with :class:`fuel.datasets.Iris`. The converted dataset is saved as 'iris.hdf5'. This method assumes the existence of the file `iris.data`. Parameters ---------- directory : str Directory in which input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to `None`, in which case a name based on `dtype` will be used. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset. """ classes = {b'Iris-setosa': 0, b'Iris-versicolor': 1, b'Iris-virginica': 2} data = numpy.loadtxt( os.path.join(directory, 'iris.data'), converters={4: lambda x: classes[x]}, delimiter=',') features = data[:, :-1].astype('float32') targets = data[:, -1].astype('uint8').reshape((-1, 1)) data = (('all', 'features', features), ('all', 'targets', targets)) output_path = os.path.join(output_directory, output_filename) h5file = h5py.File(output_path, mode='w') fill_hdf5_file(h5file, data) h5file['features'].dims[0].label = 'batch' h5file['features'].dims[1].label = 'feature' h5file['targets'].dims[0].label = 'batch' h5file['targets'].dims[1].label = 'index' h5file.flush() h5file.close() return (output_path,)
[ "def", "convert_iris", "(", "directory", ",", "output_directory", ",", "output_filename", "=", "'iris.hdf5'", ")", ":", "classes", "=", "{", "b'Iris-setosa'", ":", "0", ",", "b'Iris-versicolor'", ":", "1", ",", "b'Iris-virginica'", ":", "2", "}", "data", "=", "numpy", ".", "loadtxt", "(", "os", ".", "path", ".", "join", "(", "directory", ",", "'iris.data'", ")", ",", "converters", "=", "{", "4", ":", "lambda", "x", ":", "classes", "[", "x", "]", "}", ",", "delimiter", "=", "','", ")", "features", "=", "data", "[", ":", ",", ":", "-", "1", "]", ".", "astype", "(", "'float32'", ")", "targets", "=", "data", "[", ":", ",", "-", "1", "]", ".", "astype", "(", "'uint8'", ")", ".", "reshape", "(", "(", "-", "1", ",", "1", ")", ")", "data", "=", "(", "(", "'all'", ",", "'features'", ",", "features", ")", ",", "(", "'all'", ",", "'targets'", ",", "targets", ")", ")", "output_path", "=", "os", ".", "path", ".", "join", "(", "output_directory", ",", "output_filename", ")", "h5file", "=", "h5py", ".", "File", "(", "output_path", ",", "mode", "=", "'w'", ")", "fill_hdf5_file", "(", "h5file", ",", "data", ")", "h5file", "[", "'features'", "]", ".", "dims", "[", "0", "]", ".", "label", "=", "'batch'", "h5file", "[", "'features'", "]", ".", "dims", "[", "1", "]", ".", "label", "=", "'feature'", "h5file", "[", "'targets'", "]", ".", "dims", "[", "0", "]", ".", "label", "=", "'batch'", "h5file", "[", "'targets'", "]", ".", "dims", "[", "1", "]", ".", "label", "=", "'index'", "h5file", ".", "flush", "(", ")", "h5file", ".", "close", "(", ")", "return", "(", "output_path", ",", ")" ]
Convert the Iris dataset to HDF5. Converts the Iris dataset to an HDF5 dataset compatible with :class:`fuel.datasets.Iris`. The converted dataset is saved as 'iris.hdf5'. This method assumes the existence of the file `iris.data`. Parameters ---------- directory : str Directory in which input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to `None`, in which case a name based on `dtype` will be used. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset.
[ "Convert", "the", "Iris", "dataset", "to", "HDF5", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/iris.py#L9-L54
train
mila-iqia/fuel
fuel/downloaders/ilsvrc2012.py
fill_subparser
def fill_subparser(subparser): """Sets up a subparser to download the ILSVRC2012 dataset files. Note that you will need to use `--url-prefix` to download the non-public files (namely, the TARs of images). This is a single prefix that is common to all distributed files, which you can obtain by registering at the ImageNet website [DOWNLOAD]. Note that these files are quite large and you may be better off simply downloading them separately and running ``fuel-convert``. .. [DOWNLOAD] http://www.image-net.org/download-images Parameters ---------- subparser : :class:`argparse.ArgumentParser` Subparser handling the `ilsvrc2012` command. """ urls = ([None] * len(ALL_FILES)) filenames = list(ALL_FILES) subparser.set_defaults(urls=urls, filenames=filenames) subparser.add_argument('-P', '--url-prefix', type=str, default=None, help="URL prefix to prepend to the filenames of " "non-public files, in order to download them. " "Be sure to include the trailing slash.") return default_downloader
python
def fill_subparser(subparser): """Sets up a subparser to download the ILSVRC2012 dataset files. Note that you will need to use `--url-prefix` to download the non-public files (namely, the TARs of images). This is a single prefix that is common to all distributed files, which you can obtain by registering at the ImageNet website [DOWNLOAD]. Note that these files are quite large and you may be better off simply downloading them separately and running ``fuel-convert``. .. [DOWNLOAD] http://www.image-net.org/download-images Parameters ---------- subparser : :class:`argparse.ArgumentParser` Subparser handling the `ilsvrc2012` command. """ urls = ([None] * len(ALL_FILES)) filenames = list(ALL_FILES) subparser.set_defaults(urls=urls, filenames=filenames) subparser.add_argument('-P', '--url-prefix', type=str, default=None, help="URL prefix to prepend to the filenames of " "non-public files, in order to download them. " "Be sure to include the trailing slash.") return default_downloader
[ "def", "fill_subparser", "(", "subparser", ")", ":", "urls", "=", "(", "[", "None", "]", "*", "len", "(", "ALL_FILES", ")", ")", "filenames", "=", "list", "(", "ALL_FILES", ")", "subparser", ".", "set_defaults", "(", "urls", "=", "urls", ",", "filenames", "=", "filenames", ")", "subparser", ".", "add_argument", "(", "'-P'", ",", "'--url-prefix'", ",", "type", "=", "str", ",", "default", "=", "None", ",", "help", "=", "\"URL prefix to prepend to the filenames of \"", "\"non-public files, in order to download them. \"", "\"Be sure to include the trailing slash.\"", ")", "return", "default_downloader" ]
Sets up a subparser to download the ILSVRC2012 dataset files. Note that you will need to use `--url-prefix` to download the non-public files (namely, the TARs of images). This is a single prefix that is common to all distributed files, which you can obtain by registering at the ImageNet website [DOWNLOAD]. Note that these files are quite large and you may be better off simply downloading them separately and running ``fuel-convert``. .. [DOWNLOAD] http://www.image-net.org/download-images Parameters ---------- subparser : :class:`argparse.ArgumentParser` Subparser handling the `ilsvrc2012` command.
[ "Sets", "up", "a", "subparser", "to", "download", "the", "ILSVRC2012", "dataset", "files", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/downloaders/ilsvrc2012.py#L5-L32
train
mila-iqia/fuel
fuel/transformers/sequences.py
Window._get_target_index
def _get_target_index(self): """Return the index where the target window starts.""" return (self.index + self.source_window * (not self.overlapping) + self.offset)
python
def _get_target_index(self): """Return the index where the target window starts.""" return (self.index + self.source_window * (not self.overlapping) + self.offset)
[ "def", "_get_target_index", "(", "self", ")", ":", "return", "(", "self", ".", "index", "+", "self", ".", "source_window", "*", "(", "not", "self", ".", "overlapping", ")", "+", "self", ".", "offset", ")" ]
Return the index where the target window starts.
[ "Return", "the", "index", "where", "the", "target", "window", "starts", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/transformers/sequences.py#L66-L69
train
mila-iqia/fuel
fuel/transformers/sequences.py
Window._get_end_index
def _get_end_index(self): """Return the end of both windows.""" return max(self.index + self.source_window, self._get_target_index() + self.target_window)
python
def _get_end_index(self): """Return the end of both windows.""" return max(self.index + self.source_window, self._get_target_index() + self.target_window)
[ "def", "_get_end_index", "(", "self", ")", ":", "return", "max", "(", "self", ".", "index", "+", "self", ".", "source_window", ",", "self", ".", "_get_target_index", "(", ")", "+", "self", ".", "target_window", ")" ]
Return the end of both windows.
[ "Return", "the", "end", "of", "both", "windows", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/transformers/sequences.py#L71-L74
train
mila-iqia/fuel
fuel/converters/svhn.py
convert_svhn
def convert_svhn(which_format, directory, output_directory, output_filename=None): """Converts the SVHN dataset to HDF5. Converts the SVHN dataset [SVHN] to an HDF5 dataset compatible with :class:`fuel.datasets.SVHN`. The converted dataset is saved as 'svhn_format_1.hdf5' or 'svhn_format_2.hdf5', depending on the `which_format` argument. .. [SVHN] Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, Andrew Y. Ng. *Reading Digits in Natural Images with Unsupervised Feature Learning*, NIPS Workshop on Deep Learning and Unsupervised Feature Learning, 2011. Parameters ---------- which_format : int Either 1 or 2. Determines which format (format 1: full numbers or format 2: cropped digits) to convert. directory : str Directory in which input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to 'svhn_format_1.hdf5' or 'svhn_format_2.hdf5', depending on `which_format`. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset. """ if which_format not in (1, 2): raise ValueError("SVHN format needs to be either 1 or 2.") if not output_filename: output_filename = 'svhn_format_{}.hdf5'.format(which_format) if which_format == 1: return convert_svhn_format_1( directory, output_directory, output_filename) else: return convert_svhn_format_2( directory, output_directory, output_filename)
python
def convert_svhn(which_format, directory, output_directory, output_filename=None): """Converts the SVHN dataset to HDF5. Converts the SVHN dataset [SVHN] to an HDF5 dataset compatible with :class:`fuel.datasets.SVHN`. The converted dataset is saved as 'svhn_format_1.hdf5' or 'svhn_format_2.hdf5', depending on the `which_format` argument. .. [SVHN] Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, Andrew Y. Ng. *Reading Digits in Natural Images with Unsupervised Feature Learning*, NIPS Workshop on Deep Learning and Unsupervised Feature Learning, 2011. Parameters ---------- which_format : int Either 1 or 2. Determines which format (format 1: full numbers or format 2: cropped digits) to convert. directory : str Directory in which input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to 'svhn_format_1.hdf5' or 'svhn_format_2.hdf5', depending on `which_format`. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset. """ if which_format not in (1, 2): raise ValueError("SVHN format needs to be either 1 or 2.") if not output_filename: output_filename = 'svhn_format_{}.hdf5'.format(which_format) if which_format == 1: return convert_svhn_format_1( directory, output_directory, output_filename) else: return convert_svhn_format_2( directory, output_directory, output_filename)
[ "def", "convert_svhn", "(", "which_format", ",", "directory", ",", "output_directory", ",", "output_filename", "=", "None", ")", ":", "if", "which_format", "not", "in", "(", "1", ",", "2", ")", ":", "raise", "ValueError", "(", "\"SVHN format needs to be either 1 or 2.\"", ")", "if", "not", "output_filename", ":", "output_filename", "=", "'svhn_format_{}.hdf5'", ".", "format", "(", "which_format", ")", "if", "which_format", "==", "1", ":", "return", "convert_svhn_format_1", "(", "directory", ",", "output_directory", ",", "output_filename", ")", "else", ":", "return", "convert_svhn_format_2", "(", "directory", ",", "output_directory", ",", "output_filename", ")" ]
Converts the SVHN dataset to HDF5. Converts the SVHN dataset [SVHN] to an HDF5 dataset compatible with :class:`fuel.datasets.SVHN`. The converted dataset is saved as 'svhn_format_1.hdf5' or 'svhn_format_2.hdf5', depending on the `which_format` argument. .. [SVHN] Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, Andrew Y. Ng. *Reading Digits in Natural Images with Unsupervised Feature Learning*, NIPS Workshop on Deep Learning and Unsupervised Feature Learning, 2011. Parameters ---------- which_format : int Either 1 or 2. Determines which format (format 1: full numbers or format 2: cropped digits) to convert. directory : str Directory in which input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to 'svhn_format_1.hdf5' or 'svhn_format_2.hdf5', depending on `which_format`. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset.
[ "Converts", "the", "SVHN", "dataset", "to", "HDF5", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/svhn.py#L327-L369
train
mila-iqia/fuel
fuel/utils/formats.py
open_
def open_(filename, mode='r', encoding=None): """Open a text file with encoding and optional gzip compression. Note that on legacy Python any encoding other than ``None`` or opening GZipped files will return an unpicklable file-like object. Parameters ---------- filename : str The filename to read. mode : str, optional The mode with which to open the file. Defaults to `r`. encoding : str, optional The encoding to use (see the codecs documentation_ for supported values). Defaults to ``None``. .. _documentation: https://docs.python.org/3/library/codecs.html#standard-encodings """ if filename.endswith('.gz'): if six.PY2: zf = io.BufferedReader(gzip.open(filename, mode)) if encoding: return codecs.getreader(encoding)(zf) else: return zf else: return io.BufferedReader(gzip.open(filename, mode, encoding=encoding)) if six.PY2: if encoding: return codecs.open(filename, mode, encoding=encoding) else: return open(filename, mode) else: return open(filename, mode, encoding=encoding)
python
def open_(filename, mode='r', encoding=None): """Open a text file with encoding and optional gzip compression. Note that on legacy Python any encoding other than ``None`` or opening GZipped files will return an unpicklable file-like object. Parameters ---------- filename : str The filename to read. mode : str, optional The mode with which to open the file. Defaults to `r`. encoding : str, optional The encoding to use (see the codecs documentation_ for supported values). Defaults to ``None``. .. _documentation: https://docs.python.org/3/library/codecs.html#standard-encodings """ if filename.endswith('.gz'): if six.PY2: zf = io.BufferedReader(gzip.open(filename, mode)) if encoding: return codecs.getreader(encoding)(zf) else: return zf else: return io.BufferedReader(gzip.open(filename, mode, encoding=encoding)) if six.PY2: if encoding: return codecs.open(filename, mode, encoding=encoding) else: return open(filename, mode) else: return open(filename, mode, encoding=encoding)
[ "def", "open_", "(", "filename", ",", "mode", "=", "'r'", ",", "encoding", "=", "None", ")", ":", "if", "filename", ".", "endswith", "(", "'.gz'", ")", ":", "if", "six", ".", "PY2", ":", "zf", "=", "io", ".", "BufferedReader", "(", "gzip", ".", "open", "(", "filename", ",", "mode", ")", ")", "if", "encoding", ":", "return", "codecs", ".", "getreader", "(", "encoding", ")", "(", "zf", ")", "else", ":", "return", "zf", "else", ":", "return", "io", ".", "BufferedReader", "(", "gzip", ".", "open", "(", "filename", ",", "mode", ",", "encoding", "=", "encoding", ")", ")", "if", "six", ".", "PY2", ":", "if", "encoding", ":", "return", "codecs", ".", "open", "(", "filename", ",", "mode", ",", "encoding", "=", "encoding", ")", "else", ":", "return", "open", "(", "filename", ",", "mode", ")", "else", ":", "return", "open", "(", "filename", ",", "mode", ",", "encoding", "=", "encoding", ")" ]
Open a text file with encoding and optional gzip compression. Note that on legacy Python any encoding other than ``None`` or opening GZipped files will return an unpicklable file-like object. Parameters ---------- filename : str The filename to read. mode : str, optional The mode with which to open the file. Defaults to `r`. encoding : str, optional The encoding to use (see the codecs documentation_ for supported values). Defaults to ``None``. .. _documentation: https://docs.python.org/3/library/codecs.html#standard-encodings
[ "Open", "a", "text", "file", "with", "encoding", "and", "optional", "gzip", "compression", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/utils/formats.py#L9-L45
train
mila-iqia/fuel
fuel/utils/formats.py
tar_open
def tar_open(f): """Open either a filename or a file-like object as a TarFile. Parameters ---------- f : str or file-like object The filename or file-like object from which to read. Returns ------- TarFile A `TarFile` instance. """ if isinstance(f, six.string_types): return tarfile.open(name=f) else: return tarfile.open(fileobj=f)
python
def tar_open(f): """Open either a filename or a file-like object as a TarFile. Parameters ---------- f : str or file-like object The filename or file-like object from which to read. Returns ------- TarFile A `TarFile` instance. """ if isinstance(f, six.string_types): return tarfile.open(name=f) else: return tarfile.open(fileobj=f)
[ "def", "tar_open", "(", "f", ")", ":", "if", "isinstance", "(", "f", ",", "six", ".", "string_types", ")", ":", "return", "tarfile", ".", "open", "(", "name", "=", "f", ")", "else", ":", "return", "tarfile", ".", "open", "(", "fileobj", "=", "f", ")" ]
Open either a filename or a file-like object as a TarFile. Parameters ---------- f : str or file-like object The filename or file-like object from which to read. Returns ------- TarFile A `TarFile` instance.
[ "Open", "either", "a", "filename", "or", "a", "file", "-", "like", "object", "as", "a", "TarFile", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/utils/formats.py#L48-L65
train
mila-iqia/fuel
fuel/utils/cache.py
copy_from_server_to_local
def copy_from_server_to_local(dataset_remote_dir, dataset_local_dir, remote_fname, local_fname): """Copies a remote file locally. Parameters ---------- remote_fname : str Remote file to copy local_fname : str Path and name of the local copy to be made of the remote file. """ log.debug("Copying file `{}` to a local directory `{}`." .format(remote_fname, dataset_local_dir)) head, tail = os.path.split(local_fname) head += os.path.sep if not os.path.exists(head): os.makedirs(os.path.dirname(head)) shutil.copyfile(remote_fname, local_fname) # Copy the original group id and file permission st = os.stat(remote_fname) os.chmod(local_fname, st.st_mode) # If the user have read access to the data, but not a member # of the group, he can't set the group. So we must catch the # exception. But we still want to do this, for directory where # only member of the group can read that data. try: os.chown(local_fname, -1, st.st_gid) except OSError: pass # Need to give group write permission to the folders # For the locking mechanism # Try to set the original group as above dirs = os.path.dirname(local_fname).replace(dataset_local_dir, '') sep = dirs.split(os.path.sep) if sep[0] == "": sep = sep[1:] for i in range(len(sep)): orig_p = os.path.join(dataset_remote_dir, *sep[:i + 1]) new_p = os.path.join(dataset_local_dir, *sep[:i + 1]) orig_st = os.stat(orig_p) new_st = os.stat(new_p) if not new_st.st_mode & stat.S_IWGRP: os.chmod(new_p, new_st.st_mode | stat.S_IWGRP) if orig_st.st_gid != new_st.st_gid: try: os.chown(new_p, -1, orig_st.st_gid) except OSError: pass
python
def copy_from_server_to_local(dataset_remote_dir, dataset_local_dir, remote_fname, local_fname): """Copies a remote file locally. Parameters ---------- remote_fname : str Remote file to copy local_fname : str Path and name of the local copy to be made of the remote file. """ log.debug("Copying file `{}` to a local directory `{}`." .format(remote_fname, dataset_local_dir)) head, tail = os.path.split(local_fname) head += os.path.sep if not os.path.exists(head): os.makedirs(os.path.dirname(head)) shutil.copyfile(remote_fname, local_fname) # Copy the original group id and file permission st = os.stat(remote_fname) os.chmod(local_fname, st.st_mode) # If the user have read access to the data, but not a member # of the group, he can't set the group. So we must catch the # exception. But we still want to do this, for directory where # only member of the group can read that data. try: os.chown(local_fname, -1, st.st_gid) except OSError: pass # Need to give group write permission to the folders # For the locking mechanism # Try to set the original group as above dirs = os.path.dirname(local_fname).replace(dataset_local_dir, '') sep = dirs.split(os.path.sep) if sep[0] == "": sep = sep[1:] for i in range(len(sep)): orig_p = os.path.join(dataset_remote_dir, *sep[:i + 1]) new_p = os.path.join(dataset_local_dir, *sep[:i + 1]) orig_st = os.stat(orig_p) new_st = os.stat(new_p) if not new_st.st_mode & stat.S_IWGRP: os.chmod(new_p, new_st.st_mode | stat.S_IWGRP) if orig_st.st_gid != new_st.st_gid: try: os.chown(new_p, -1, orig_st.st_gid) except OSError: pass
[ "def", "copy_from_server_to_local", "(", "dataset_remote_dir", ",", "dataset_local_dir", ",", "remote_fname", ",", "local_fname", ")", ":", "log", ".", "debug", "(", "\"Copying file `{}` to a local directory `{}`.\"", ".", "format", "(", "remote_fname", ",", "dataset_local_dir", ")", ")", "head", ",", "tail", "=", "os", ".", "path", ".", "split", "(", "local_fname", ")", "head", "+=", "os", ".", "path", ".", "sep", "if", "not", "os", ".", "path", ".", "exists", "(", "head", ")", ":", "os", ".", "makedirs", "(", "os", ".", "path", ".", "dirname", "(", "head", ")", ")", "shutil", ".", "copyfile", "(", "remote_fname", ",", "local_fname", ")", "# Copy the original group id and file permission", "st", "=", "os", ".", "stat", "(", "remote_fname", ")", "os", ".", "chmod", "(", "local_fname", ",", "st", ".", "st_mode", ")", "# If the user have read access to the data, but not a member", "# of the group, he can't set the group. So we must catch the", "# exception. But we still want to do this, for directory where", "# only member of the group can read that data.", "try", ":", "os", ".", "chown", "(", "local_fname", ",", "-", "1", ",", "st", ".", "st_gid", ")", "except", "OSError", ":", "pass", "# Need to give group write permission to the folders", "# For the locking mechanism", "# Try to set the original group as above", "dirs", "=", "os", ".", "path", ".", "dirname", "(", "local_fname", ")", ".", "replace", "(", "dataset_local_dir", ",", "''", ")", "sep", "=", "dirs", ".", "split", "(", "os", ".", "path", ".", "sep", ")", "if", "sep", "[", "0", "]", "==", "\"\"", ":", "sep", "=", "sep", "[", "1", ":", "]", "for", "i", "in", "range", "(", "len", "(", "sep", ")", ")", ":", "orig_p", "=", "os", ".", "path", ".", "join", "(", "dataset_remote_dir", ",", "*", "sep", "[", ":", "i", "+", "1", "]", ")", "new_p", "=", "os", ".", "path", ".", "join", "(", "dataset_local_dir", ",", "*", "sep", "[", ":", "i", "+", "1", "]", ")", "orig_st", "=", "os", ".", "stat", "(", "orig_p", ")", "new_st", "=", "os", ".", "stat", "(", "new_p", ")", "if", "not", "new_st", ".", "st_mode", "&", "stat", ".", "S_IWGRP", ":", "os", ".", "chmod", "(", "new_p", ",", "new_st", ".", "st_mode", "|", "stat", ".", "S_IWGRP", ")", "if", "orig_st", ".", "st_gid", "!=", "new_st", ".", "st_gid", ":", "try", ":", "os", ".", "chown", "(", "new_p", ",", "-", "1", ",", "orig_st", ".", "st_gid", ")", "except", "OSError", ":", "pass" ]
Copies a remote file locally. Parameters ---------- remote_fname : str Remote file to copy local_fname : str Path and name of the local copy to be made of the remote file.
[ "Copies", "a", "remote", "file", "locally", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/utils/cache.py#L217-L269
train
mila-iqia/fuel
fuel/converters/adult.py
convert_to_one_hot
def convert_to_one_hot(y): """ converts y into one hot reprsentation. Parameters ---------- y : list A list containing continous integer values. Returns ------- one_hot : numpy.ndarray A numpy.ndarray object, which is one-hot representation of y. """ max_value = max(y) min_value = min(y) length = len(y) one_hot = numpy.zeros((length, (max_value - min_value + 1))) one_hot[numpy.arange(length), y] = 1 return one_hot
python
def convert_to_one_hot(y): """ converts y into one hot reprsentation. Parameters ---------- y : list A list containing continous integer values. Returns ------- one_hot : numpy.ndarray A numpy.ndarray object, which is one-hot representation of y. """ max_value = max(y) min_value = min(y) length = len(y) one_hot = numpy.zeros((length, (max_value - min_value + 1))) one_hot[numpy.arange(length), y] = 1 return one_hot
[ "def", "convert_to_one_hot", "(", "y", ")", ":", "max_value", "=", "max", "(", "y", ")", "min_value", "=", "min", "(", "y", ")", "length", "=", "len", "(", "y", ")", "one_hot", "=", "numpy", ".", "zeros", "(", "(", "length", ",", "(", "max_value", "-", "min_value", "+", "1", ")", ")", ")", "one_hot", "[", "numpy", ".", "arange", "(", "length", ")", ",", "y", "]", "=", "1", "return", "one_hot" ]
converts y into one hot reprsentation. Parameters ---------- y : list A list containing continous integer values. Returns ------- one_hot : numpy.ndarray A numpy.ndarray object, which is one-hot representation of y.
[ "converts", "y", "into", "one", "hot", "reprsentation", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/adult.py#L9-L29
train
mila-iqia/fuel
fuel/converters/binarized_mnist.py
convert_binarized_mnist
def convert_binarized_mnist(directory, output_directory, output_filename='binarized_mnist.hdf5'): """Converts the binarized MNIST dataset to HDF5. Converts the binarized MNIST dataset used in R. Salakhutdinov's DBN paper [DBN] to an HDF5 dataset compatible with :class:`fuel.datasets.BinarizedMNIST`. The converted dataset is saved as 'binarized_mnist.hdf5'. This method assumes the existence of the files `binarized_mnist_{train,valid,test}.amat`, which are accessible through Hugo Larochelle's website [HUGO]. .. [DBN] Ruslan Salakhutdinov and Iain Murray, *On the Quantitative Analysis of Deep Belief Networks*, Proceedings of the 25th international conference on Machine learning, 2008, pp. 872-879. Parameters ---------- directory : str Directory in which input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to 'binarized_mnist.hdf5'. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset. """ output_path = os.path.join(output_directory, output_filename) h5file = h5py.File(output_path, mode='w') train_set = numpy.loadtxt( os.path.join(directory, TRAIN_FILE)).reshape( (-1, 1, 28, 28)).astype('uint8') valid_set = numpy.loadtxt( os.path.join(directory, VALID_FILE)).reshape( (-1, 1, 28, 28)).astype('uint8') test_set = numpy.loadtxt( os.path.join(directory, TEST_FILE)).reshape( (-1, 1, 28, 28)).astype('uint8') data = (('train', 'features', train_set), ('valid', 'features', valid_set), ('test', 'features', test_set)) fill_hdf5_file(h5file, data) for i, label in enumerate(('batch', 'channel', 'height', 'width')): h5file['features'].dims[i].label = label h5file.flush() h5file.close() return (output_path,)
python
def convert_binarized_mnist(directory, output_directory, output_filename='binarized_mnist.hdf5'): """Converts the binarized MNIST dataset to HDF5. Converts the binarized MNIST dataset used in R. Salakhutdinov's DBN paper [DBN] to an HDF5 dataset compatible with :class:`fuel.datasets.BinarizedMNIST`. The converted dataset is saved as 'binarized_mnist.hdf5'. This method assumes the existence of the files `binarized_mnist_{train,valid,test}.amat`, which are accessible through Hugo Larochelle's website [HUGO]. .. [DBN] Ruslan Salakhutdinov and Iain Murray, *On the Quantitative Analysis of Deep Belief Networks*, Proceedings of the 25th international conference on Machine learning, 2008, pp. 872-879. Parameters ---------- directory : str Directory in which input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to 'binarized_mnist.hdf5'. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset. """ output_path = os.path.join(output_directory, output_filename) h5file = h5py.File(output_path, mode='w') train_set = numpy.loadtxt( os.path.join(directory, TRAIN_FILE)).reshape( (-1, 1, 28, 28)).astype('uint8') valid_set = numpy.loadtxt( os.path.join(directory, VALID_FILE)).reshape( (-1, 1, 28, 28)).astype('uint8') test_set = numpy.loadtxt( os.path.join(directory, TEST_FILE)).reshape( (-1, 1, 28, 28)).astype('uint8') data = (('train', 'features', train_set), ('valid', 'features', valid_set), ('test', 'features', test_set)) fill_hdf5_file(h5file, data) for i, label in enumerate(('batch', 'channel', 'height', 'width')): h5file['features'].dims[i].label = label h5file.flush() h5file.close() return (output_path,)
[ "def", "convert_binarized_mnist", "(", "directory", ",", "output_directory", ",", "output_filename", "=", "'binarized_mnist.hdf5'", ")", ":", "output_path", "=", "os", ".", "path", ".", "join", "(", "output_directory", ",", "output_filename", ")", "h5file", "=", "h5py", ".", "File", "(", "output_path", ",", "mode", "=", "'w'", ")", "train_set", "=", "numpy", ".", "loadtxt", "(", "os", ".", "path", ".", "join", "(", "directory", ",", "TRAIN_FILE", ")", ")", ".", "reshape", "(", "(", "-", "1", ",", "1", ",", "28", ",", "28", ")", ")", ".", "astype", "(", "'uint8'", ")", "valid_set", "=", "numpy", ".", "loadtxt", "(", "os", ".", "path", ".", "join", "(", "directory", ",", "VALID_FILE", ")", ")", ".", "reshape", "(", "(", "-", "1", ",", "1", ",", "28", ",", "28", ")", ")", ".", "astype", "(", "'uint8'", ")", "test_set", "=", "numpy", ".", "loadtxt", "(", "os", ".", "path", ".", "join", "(", "directory", ",", "TEST_FILE", ")", ")", ".", "reshape", "(", "(", "-", "1", ",", "1", ",", "28", ",", "28", ")", ")", ".", "astype", "(", "'uint8'", ")", "data", "=", "(", "(", "'train'", ",", "'features'", ",", "train_set", ")", ",", "(", "'valid'", ",", "'features'", ",", "valid_set", ")", ",", "(", "'test'", ",", "'features'", ",", "test_set", ")", ")", "fill_hdf5_file", "(", "h5file", ",", "data", ")", "for", "i", ",", "label", "in", "enumerate", "(", "(", "'batch'", ",", "'channel'", ",", "'height'", ",", "'width'", ")", ")", ":", "h5file", "[", "'features'", "]", ".", "dims", "[", "i", "]", ".", "label", "=", "label", "h5file", ".", "flush", "(", ")", "h5file", ".", "close", "(", ")", "return", "(", "output_path", ",", ")" ]
Converts the binarized MNIST dataset to HDF5. Converts the binarized MNIST dataset used in R. Salakhutdinov's DBN paper [DBN] to an HDF5 dataset compatible with :class:`fuel.datasets.BinarizedMNIST`. The converted dataset is saved as 'binarized_mnist.hdf5'. This method assumes the existence of the files `binarized_mnist_{train,valid,test}.amat`, which are accessible through Hugo Larochelle's website [HUGO]. .. [DBN] Ruslan Salakhutdinov and Iain Murray, *On the Quantitative Analysis of Deep Belief Networks*, Proceedings of the 25th international conference on Machine learning, 2008, pp. 872-879. Parameters ---------- directory : str Directory in which input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to 'binarized_mnist.hdf5'. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset.
[ "Converts", "the", "binarized", "MNIST", "dataset", "to", "HDF5", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/binarized_mnist.py#L17-L71
train
mila-iqia/fuel
fuel/downloaders/cifar10.py
fill_subparser
def fill_subparser(subparser): """Sets up a subparser to download the CIFAR-10 dataset file. The CIFAR-10 dataset file is downloaded from Alex Krizhevsky's website [ALEX]. Parameters ---------- subparser : :class:`argparse.ArgumentParser` Subparser handling the `cifar10` command. """ url = 'http://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' filename = 'cifar-10-python.tar.gz' subparser.set_defaults(urls=[url], filenames=[filename]) return default_downloader
python
def fill_subparser(subparser): """Sets up a subparser to download the CIFAR-10 dataset file. The CIFAR-10 dataset file is downloaded from Alex Krizhevsky's website [ALEX]. Parameters ---------- subparser : :class:`argparse.ArgumentParser` Subparser handling the `cifar10` command. """ url = 'http://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' filename = 'cifar-10-python.tar.gz' subparser.set_defaults(urls=[url], filenames=[filename]) return default_downloader
[ "def", "fill_subparser", "(", "subparser", ")", ":", "url", "=", "'http://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz'", "filename", "=", "'cifar-10-python.tar.gz'", "subparser", ".", "set_defaults", "(", "urls", "=", "[", "url", "]", ",", "filenames", "=", "[", "filename", "]", ")", "return", "default_downloader" ]
Sets up a subparser to download the CIFAR-10 dataset file. The CIFAR-10 dataset file is downloaded from Alex Krizhevsky's website [ALEX]. Parameters ---------- subparser : :class:`argparse.ArgumentParser` Subparser handling the `cifar10` command.
[ "Sets", "up", "a", "subparser", "to", "download", "the", "CIFAR", "-", "10", "dataset", "file", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/downloaders/cifar10.py#L4-L19
train
mila-iqia/fuel
fuel/converters/celeba.py
convert_celeba_aligned_cropped
def convert_celeba_aligned_cropped(directory, output_directory, output_filename=OUTPUT_FILENAME): """Converts the aligned and cropped CelebA dataset to HDF5. Converts the CelebA dataset to an HDF5 dataset compatible with :class:`fuel.datasets.CelebA`. The converted dataset is saved as 'celeba_aligned_cropped.hdf5'. It assumes the existence of the following files: * `img_align_celeba.zip` * `list_attr_celeba.txt` Parameters ---------- directory : str Directory in which input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to 'celeba_aligned_cropped.hdf5'. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset. """ output_path = os.path.join(output_directory, output_filename) h5file = _initialize_conversion(directory, output_path, (218, 178)) features_dataset = h5file['features'] image_file_path = os.path.join(directory, IMAGE_FILE) with zipfile.ZipFile(image_file_path, 'r') as image_file: with progress_bar('images', NUM_EXAMPLES) as bar: for i in range(NUM_EXAMPLES): image_name = 'img_align_celeba/{:06d}.jpg'.format(i + 1) features_dataset[i] = numpy.asarray( Image.open( image_file.open(image_name, 'r'))).transpose(2, 0, 1) bar.update(i + 1) h5file.flush() h5file.close() return (output_path,)
python
def convert_celeba_aligned_cropped(directory, output_directory, output_filename=OUTPUT_FILENAME): """Converts the aligned and cropped CelebA dataset to HDF5. Converts the CelebA dataset to an HDF5 dataset compatible with :class:`fuel.datasets.CelebA`. The converted dataset is saved as 'celeba_aligned_cropped.hdf5'. It assumes the existence of the following files: * `img_align_celeba.zip` * `list_attr_celeba.txt` Parameters ---------- directory : str Directory in which input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to 'celeba_aligned_cropped.hdf5'. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset. """ output_path = os.path.join(output_directory, output_filename) h5file = _initialize_conversion(directory, output_path, (218, 178)) features_dataset = h5file['features'] image_file_path = os.path.join(directory, IMAGE_FILE) with zipfile.ZipFile(image_file_path, 'r') as image_file: with progress_bar('images', NUM_EXAMPLES) as bar: for i in range(NUM_EXAMPLES): image_name = 'img_align_celeba/{:06d}.jpg'.format(i + 1) features_dataset[i] = numpy.asarray( Image.open( image_file.open(image_name, 'r'))).transpose(2, 0, 1) bar.update(i + 1) h5file.flush() h5file.close() return (output_path,)
[ "def", "convert_celeba_aligned_cropped", "(", "directory", ",", "output_directory", ",", "output_filename", "=", "OUTPUT_FILENAME", ")", ":", "output_path", "=", "os", ".", "path", ".", "join", "(", "output_directory", ",", "output_filename", ")", "h5file", "=", "_initialize_conversion", "(", "directory", ",", "output_path", ",", "(", "218", ",", "178", ")", ")", "features_dataset", "=", "h5file", "[", "'features'", "]", "image_file_path", "=", "os", ".", "path", ".", "join", "(", "directory", ",", "IMAGE_FILE", ")", "with", "zipfile", ".", "ZipFile", "(", "image_file_path", ",", "'r'", ")", "as", "image_file", ":", "with", "progress_bar", "(", "'images'", ",", "NUM_EXAMPLES", ")", "as", "bar", ":", "for", "i", "in", "range", "(", "NUM_EXAMPLES", ")", ":", "image_name", "=", "'img_align_celeba/{:06d}.jpg'", ".", "format", "(", "i", "+", "1", ")", "features_dataset", "[", "i", "]", "=", "numpy", ".", "asarray", "(", "Image", ".", "open", "(", "image_file", ".", "open", "(", "image_name", ",", "'r'", ")", ")", ")", ".", "transpose", "(", "2", ",", "0", ",", "1", ")", "bar", ".", "update", "(", "i", "+", "1", ")", "h5file", ".", "flush", "(", ")", "h5file", ".", "close", "(", ")", "return", "(", "output_path", ",", ")" ]
Converts the aligned and cropped CelebA dataset to HDF5. Converts the CelebA dataset to an HDF5 dataset compatible with :class:`fuel.datasets.CelebA`. The converted dataset is saved as 'celeba_aligned_cropped.hdf5'. It assumes the existence of the following files: * `img_align_celeba.zip` * `list_attr_celeba.txt` Parameters ---------- directory : str Directory in which input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to 'celeba_aligned_cropped.hdf5'. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset.
[ "Converts", "the", "aligned", "and", "cropped", "CelebA", "dataset", "to", "HDF5", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/celeba.py#L55-L102
train
mila-iqia/fuel
fuel/converters/celeba.py
convert_celeba
def convert_celeba(which_format, directory, output_directory, output_filename=None): """Converts the CelebA dataset to HDF5. Converts the CelebA dataset to an HDF5 dataset compatible with :class:`fuel.datasets.CelebA`. The converted dataset is saved as 'celeba_aligned_cropped.hdf5' or 'celeba_64.hdf5', depending on the `which_format` argument. Parameters ---------- which_format : str Either 'aligned_cropped' or '64'. Determines which format to convert to. directory : str Directory in which input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to 'celeba_aligned_cropped.hdf5' or 'celeba_64.hdf5', depending on `which_format`. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset. """ if which_format not in ('aligned_cropped', '64'): raise ValueError("CelebA format needs to be either " "'aligned_cropped' or '64'.") if not output_filename: output_filename = 'celeba_{}.hdf5'.format(which_format) if which_format == 'aligned_cropped': return convert_celeba_aligned_cropped( directory, output_directory, output_filename) else: return convert_celeba_64( directory, output_directory, output_filename)
python
def convert_celeba(which_format, directory, output_directory, output_filename=None): """Converts the CelebA dataset to HDF5. Converts the CelebA dataset to an HDF5 dataset compatible with :class:`fuel.datasets.CelebA`. The converted dataset is saved as 'celeba_aligned_cropped.hdf5' or 'celeba_64.hdf5', depending on the `which_format` argument. Parameters ---------- which_format : str Either 'aligned_cropped' or '64'. Determines which format to convert to. directory : str Directory in which input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to 'celeba_aligned_cropped.hdf5' or 'celeba_64.hdf5', depending on `which_format`. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset. """ if which_format not in ('aligned_cropped', '64'): raise ValueError("CelebA format needs to be either " "'aligned_cropped' or '64'.") if not output_filename: output_filename = 'celeba_{}.hdf5'.format(which_format) if which_format == 'aligned_cropped': return convert_celeba_aligned_cropped( directory, output_directory, output_filename) else: return convert_celeba_64( directory, output_directory, output_filename)
[ "def", "convert_celeba", "(", "which_format", ",", "directory", ",", "output_directory", ",", "output_filename", "=", "None", ")", ":", "if", "which_format", "not", "in", "(", "'aligned_cropped'", ",", "'64'", ")", ":", "raise", "ValueError", "(", "\"CelebA format needs to be either \"", "\"'aligned_cropped' or '64'.\"", ")", "if", "not", "output_filename", ":", "output_filename", "=", "'celeba_{}.hdf5'", ".", "format", "(", "which_format", ")", "if", "which_format", "==", "'aligned_cropped'", ":", "return", "convert_celeba_aligned_cropped", "(", "directory", ",", "output_directory", ",", "output_filename", ")", "else", ":", "return", "convert_celeba_64", "(", "directory", ",", "output_directory", ",", "output_filename", ")" ]
Converts the CelebA dataset to HDF5. Converts the CelebA dataset to an HDF5 dataset compatible with :class:`fuel.datasets.CelebA`. The converted dataset is saved as 'celeba_aligned_cropped.hdf5' or 'celeba_64.hdf5', depending on the `which_format` argument. Parameters ---------- which_format : str Either 'aligned_cropped' or '64'. Determines which format to convert to. directory : str Directory in which input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to 'celeba_aligned_cropped.hdf5' or 'celeba_64.hdf5', depending on `which_format`. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset.
[ "Converts", "the", "CelebA", "dataset", "to", "HDF5", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/celeba.py#L159-L198
train
mila-iqia/fuel
fuel/utils/disk.py
disk_usage
def disk_usage(path): """Return free usage about the given path, in bytes. Parameters ---------- path : str Folder for which to return disk usage Returns ------- output : tuple Tuple containing total space in the folder and currently used space in the folder """ st = os.statvfs(path) total = st.f_blocks * st.f_frsize used = (st.f_blocks - st.f_bfree) * st.f_frsize return total, used
python
def disk_usage(path): """Return free usage about the given path, in bytes. Parameters ---------- path : str Folder for which to return disk usage Returns ------- output : tuple Tuple containing total space in the folder and currently used space in the folder """ st = os.statvfs(path) total = st.f_blocks * st.f_frsize used = (st.f_blocks - st.f_bfree) * st.f_frsize return total, used
[ "def", "disk_usage", "(", "path", ")", ":", "st", "=", "os", ".", "statvfs", "(", "path", ")", "total", "=", "st", ".", "f_blocks", "*", "st", ".", "f_frsize", "used", "=", "(", "st", ".", "f_blocks", "-", "st", ".", "f_bfree", ")", "*", "st", ".", "f_frsize", "return", "total", ",", "used" ]
Return free usage about the given path, in bytes. Parameters ---------- path : str Folder for which to return disk usage Returns ------- output : tuple Tuple containing total space in the folder and currently used space in the folder
[ "Return", "free", "usage", "about", "the", "given", "path", "in", "bytes", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/utils/disk.py#L39-L57
train
mila-iqia/fuel
fuel/utils/disk.py
safe_mkdir
def safe_mkdir(folder_name, force_perm=None): """Create the specified folder. If the parent folders do not exist, they are also created. If the folder already exists, nothing is done. Parameters ---------- folder_name : str Name of the folder to create. force_perm : str Mode to use for folder creation. """ if os.path.exists(folder_name): return intermediary_folders = folder_name.split(os.path.sep) # Remove invalid elements from intermediary_folders if intermediary_folders[-1] == "": intermediary_folders = intermediary_folders[:-1] if force_perm: force_perm_path = folder_name.split(os.path.sep) if force_perm_path[-1] == "": force_perm_path = force_perm_path[:-1] for i in range(1, len(intermediary_folders)): folder_to_create = os.path.sep.join(intermediary_folders[:i + 1]) if os.path.exists(folder_to_create): continue os.mkdir(folder_to_create) if force_perm: os.chmod(folder_to_create, force_perm)
python
def safe_mkdir(folder_name, force_perm=None): """Create the specified folder. If the parent folders do not exist, they are also created. If the folder already exists, nothing is done. Parameters ---------- folder_name : str Name of the folder to create. force_perm : str Mode to use for folder creation. """ if os.path.exists(folder_name): return intermediary_folders = folder_name.split(os.path.sep) # Remove invalid elements from intermediary_folders if intermediary_folders[-1] == "": intermediary_folders = intermediary_folders[:-1] if force_perm: force_perm_path = folder_name.split(os.path.sep) if force_perm_path[-1] == "": force_perm_path = force_perm_path[:-1] for i in range(1, len(intermediary_folders)): folder_to_create = os.path.sep.join(intermediary_folders[:i + 1]) if os.path.exists(folder_to_create): continue os.mkdir(folder_to_create) if force_perm: os.chmod(folder_to_create, force_perm)
[ "def", "safe_mkdir", "(", "folder_name", ",", "force_perm", "=", "None", ")", ":", "if", "os", ".", "path", ".", "exists", "(", "folder_name", ")", ":", "return", "intermediary_folders", "=", "folder_name", ".", "split", "(", "os", ".", "path", ".", "sep", ")", "# Remove invalid elements from intermediary_folders", "if", "intermediary_folders", "[", "-", "1", "]", "==", "\"\"", ":", "intermediary_folders", "=", "intermediary_folders", "[", ":", "-", "1", "]", "if", "force_perm", ":", "force_perm_path", "=", "folder_name", ".", "split", "(", "os", ".", "path", ".", "sep", ")", "if", "force_perm_path", "[", "-", "1", "]", "==", "\"\"", ":", "force_perm_path", "=", "force_perm_path", "[", ":", "-", "1", "]", "for", "i", "in", "range", "(", "1", ",", "len", "(", "intermediary_folders", ")", ")", ":", "folder_to_create", "=", "os", ".", "path", ".", "sep", ".", "join", "(", "intermediary_folders", "[", ":", "i", "+", "1", "]", ")", "if", "os", ".", "path", ".", "exists", "(", "folder_to_create", ")", ":", "continue", "os", ".", "mkdir", "(", "folder_to_create", ")", "if", "force_perm", ":", "os", ".", "chmod", "(", "folder_to_create", ",", "force_perm", ")" ]
Create the specified folder. If the parent folders do not exist, they are also created. If the folder already exists, nothing is done. Parameters ---------- folder_name : str Name of the folder to create. force_perm : str Mode to use for folder creation.
[ "Create", "the", "specified", "folder", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/utils/disk.py#L60-L93
train
mila-iqia/fuel
fuel/utils/disk.py
check_enough_space
def check_enough_space(dataset_local_dir, remote_fname, local_fname, max_disk_usage=0.9): """Check if the given local folder has enough space. Check if the given local folder has enough space to store the specified remote file. Parameters ---------- remote_fname : str Path to the remote file remote_fname : str Path to the local folder max_disk_usage : float Fraction indicating how much of the total space in the local folder can be used before the local cache must stop adding to it. Returns ------- output : boolean True if there is enough space to store the remote file. """ storage_need = os.path.getsize(remote_fname) storage_total, storage_used = disk_usage(dataset_local_dir) # Instead of only looking if there's enough space, we ensure we do not # go over max disk usage level to avoid filling the disk/partition return ((storage_used + storage_need) < (storage_total * max_disk_usage))
python
def check_enough_space(dataset_local_dir, remote_fname, local_fname, max_disk_usage=0.9): """Check if the given local folder has enough space. Check if the given local folder has enough space to store the specified remote file. Parameters ---------- remote_fname : str Path to the remote file remote_fname : str Path to the local folder max_disk_usage : float Fraction indicating how much of the total space in the local folder can be used before the local cache must stop adding to it. Returns ------- output : boolean True if there is enough space to store the remote file. """ storage_need = os.path.getsize(remote_fname) storage_total, storage_used = disk_usage(dataset_local_dir) # Instead of only looking if there's enough space, we ensure we do not # go over max disk usage level to avoid filling the disk/partition return ((storage_used + storage_need) < (storage_total * max_disk_usage))
[ "def", "check_enough_space", "(", "dataset_local_dir", ",", "remote_fname", ",", "local_fname", ",", "max_disk_usage", "=", "0.9", ")", ":", "storage_need", "=", "os", ".", "path", ".", "getsize", "(", "remote_fname", ")", "storage_total", ",", "storage_used", "=", "disk_usage", "(", "dataset_local_dir", ")", "# Instead of only looking if there's enough space, we ensure we do not", "# go over max disk usage level to avoid filling the disk/partition", "return", "(", "(", "storage_used", "+", "storage_need", ")", "<", "(", "storage_total", "*", "max_disk_usage", ")", ")" ]
Check if the given local folder has enough space. Check if the given local folder has enough space to store the specified remote file. Parameters ---------- remote_fname : str Path to the remote file remote_fname : str Path to the local folder max_disk_usage : float Fraction indicating how much of the total space in the local folder can be used before the local cache must stop adding to it. Returns ------- output : boolean True if there is enough space to store the remote file.
[ "Check", "if", "the", "given", "local", "folder", "has", "enough", "space", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/utils/disk.py#L96-L126
train
mila-iqia/fuel
fuel/converters/cifar100.py
convert_cifar100
def convert_cifar100(directory, output_directory, output_filename='cifar100.hdf5'): """Converts the CIFAR-100 dataset to HDF5. Converts the CIFAR-100 dataset to an HDF5 dataset compatible with :class:`fuel.datasets.CIFAR100`. The converted dataset is saved as 'cifar100.hdf5'. This method assumes the existence of the following file: `cifar-100-python.tar.gz` Parameters ---------- directory : str Directory in which the required input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to 'cifar100.hdf5'. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset. """ output_path = os.path.join(output_directory, output_filename) h5file = h5py.File(output_path, mode="w") input_file = os.path.join(directory, 'cifar-100-python.tar.gz') tar_file = tarfile.open(input_file, 'r:gz') file = tar_file.extractfile('cifar-100-python/train') try: if six.PY3: train = cPickle.load(file, encoding='latin1') else: train = cPickle.load(file) finally: file.close() train_features = train['data'].reshape(train['data'].shape[0], 3, 32, 32) train_coarse_labels = numpy.array(train['coarse_labels'], dtype=numpy.uint8) train_fine_labels = numpy.array(train['fine_labels'], dtype=numpy.uint8) file = tar_file.extractfile('cifar-100-python/test') try: if six.PY3: test = cPickle.load(file, encoding='latin1') else: test = cPickle.load(file) finally: file.close() test_features = test['data'].reshape(test['data'].shape[0], 3, 32, 32) test_coarse_labels = numpy.array(test['coarse_labels'], dtype=numpy.uint8) test_fine_labels = numpy.array(test['fine_labels'], dtype=numpy.uint8) data = (('train', 'features', train_features), ('train', 'coarse_labels', train_coarse_labels.reshape((-1, 1))), ('train', 'fine_labels', train_fine_labels.reshape((-1, 1))), ('test', 'features', test_features), ('test', 'coarse_labels', test_coarse_labels.reshape((-1, 1))), ('test', 'fine_labels', test_fine_labels.reshape((-1, 1)))) fill_hdf5_file(h5file, data) h5file['features'].dims[0].label = 'batch' h5file['features'].dims[1].label = 'channel' h5file['features'].dims[2].label = 'height' h5file['features'].dims[3].label = 'width' h5file['coarse_labels'].dims[0].label = 'batch' h5file['coarse_labels'].dims[1].label = 'index' h5file['fine_labels'].dims[0].label = 'batch' h5file['fine_labels'].dims[1].label = 'index' h5file.flush() h5file.close() return (output_path,)
python
def convert_cifar100(directory, output_directory, output_filename='cifar100.hdf5'): """Converts the CIFAR-100 dataset to HDF5. Converts the CIFAR-100 dataset to an HDF5 dataset compatible with :class:`fuel.datasets.CIFAR100`. The converted dataset is saved as 'cifar100.hdf5'. This method assumes the existence of the following file: `cifar-100-python.tar.gz` Parameters ---------- directory : str Directory in which the required input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to 'cifar100.hdf5'. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset. """ output_path = os.path.join(output_directory, output_filename) h5file = h5py.File(output_path, mode="w") input_file = os.path.join(directory, 'cifar-100-python.tar.gz') tar_file = tarfile.open(input_file, 'r:gz') file = tar_file.extractfile('cifar-100-python/train') try: if six.PY3: train = cPickle.load(file, encoding='latin1') else: train = cPickle.load(file) finally: file.close() train_features = train['data'].reshape(train['data'].shape[0], 3, 32, 32) train_coarse_labels = numpy.array(train['coarse_labels'], dtype=numpy.uint8) train_fine_labels = numpy.array(train['fine_labels'], dtype=numpy.uint8) file = tar_file.extractfile('cifar-100-python/test') try: if six.PY3: test = cPickle.load(file, encoding='latin1') else: test = cPickle.load(file) finally: file.close() test_features = test['data'].reshape(test['data'].shape[0], 3, 32, 32) test_coarse_labels = numpy.array(test['coarse_labels'], dtype=numpy.uint8) test_fine_labels = numpy.array(test['fine_labels'], dtype=numpy.uint8) data = (('train', 'features', train_features), ('train', 'coarse_labels', train_coarse_labels.reshape((-1, 1))), ('train', 'fine_labels', train_fine_labels.reshape((-1, 1))), ('test', 'features', test_features), ('test', 'coarse_labels', test_coarse_labels.reshape((-1, 1))), ('test', 'fine_labels', test_fine_labels.reshape((-1, 1)))) fill_hdf5_file(h5file, data) h5file['features'].dims[0].label = 'batch' h5file['features'].dims[1].label = 'channel' h5file['features'].dims[2].label = 'height' h5file['features'].dims[3].label = 'width' h5file['coarse_labels'].dims[0].label = 'batch' h5file['coarse_labels'].dims[1].label = 'index' h5file['fine_labels'].dims[0].label = 'batch' h5file['fine_labels'].dims[1].label = 'index' h5file.flush() h5file.close() return (output_path,)
[ "def", "convert_cifar100", "(", "directory", ",", "output_directory", ",", "output_filename", "=", "'cifar100.hdf5'", ")", ":", "output_path", "=", "os", ".", "path", ".", "join", "(", "output_directory", ",", "output_filename", ")", "h5file", "=", "h5py", ".", "File", "(", "output_path", ",", "mode", "=", "\"w\"", ")", "input_file", "=", "os", ".", "path", ".", "join", "(", "directory", ",", "'cifar-100-python.tar.gz'", ")", "tar_file", "=", "tarfile", ".", "open", "(", "input_file", ",", "'r:gz'", ")", "file", "=", "tar_file", ".", "extractfile", "(", "'cifar-100-python/train'", ")", "try", ":", "if", "six", ".", "PY3", ":", "train", "=", "cPickle", ".", "load", "(", "file", ",", "encoding", "=", "'latin1'", ")", "else", ":", "train", "=", "cPickle", ".", "load", "(", "file", ")", "finally", ":", "file", ".", "close", "(", ")", "train_features", "=", "train", "[", "'data'", "]", ".", "reshape", "(", "train", "[", "'data'", "]", ".", "shape", "[", "0", "]", ",", "3", ",", "32", ",", "32", ")", "train_coarse_labels", "=", "numpy", ".", "array", "(", "train", "[", "'coarse_labels'", "]", ",", "dtype", "=", "numpy", ".", "uint8", ")", "train_fine_labels", "=", "numpy", ".", "array", "(", "train", "[", "'fine_labels'", "]", ",", "dtype", "=", "numpy", ".", "uint8", ")", "file", "=", "tar_file", ".", "extractfile", "(", "'cifar-100-python/test'", ")", "try", ":", "if", "six", ".", "PY3", ":", "test", "=", "cPickle", ".", "load", "(", "file", ",", "encoding", "=", "'latin1'", ")", "else", ":", "test", "=", "cPickle", ".", "load", "(", "file", ")", "finally", ":", "file", ".", "close", "(", ")", "test_features", "=", "test", "[", "'data'", "]", ".", "reshape", "(", "test", "[", "'data'", "]", ".", "shape", "[", "0", "]", ",", "3", ",", "32", ",", "32", ")", "test_coarse_labels", "=", "numpy", ".", "array", "(", "test", "[", "'coarse_labels'", "]", ",", "dtype", "=", "numpy", ".", "uint8", ")", "test_fine_labels", "=", "numpy", ".", "array", "(", "test", "[", "'fine_labels'", "]", ",", "dtype", "=", "numpy", ".", "uint8", ")", "data", "=", "(", "(", "'train'", ",", "'features'", ",", "train_features", ")", ",", "(", "'train'", ",", "'coarse_labels'", ",", "train_coarse_labels", ".", "reshape", "(", "(", "-", "1", ",", "1", ")", ")", ")", ",", "(", "'train'", ",", "'fine_labels'", ",", "train_fine_labels", ".", "reshape", "(", "(", "-", "1", ",", "1", ")", ")", ")", ",", "(", "'test'", ",", "'features'", ",", "test_features", ")", ",", "(", "'test'", ",", "'coarse_labels'", ",", "test_coarse_labels", ".", "reshape", "(", "(", "-", "1", ",", "1", ")", ")", ")", ",", "(", "'test'", ",", "'fine_labels'", ",", "test_fine_labels", ".", "reshape", "(", "(", "-", "1", ",", "1", ")", ")", ")", ")", "fill_hdf5_file", "(", "h5file", ",", "data", ")", "h5file", "[", "'features'", "]", ".", "dims", "[", "0", "]", ".", "label", "=", "'batch'", "h5file", "[", "'features'", "]", ".", "dims", "[", "1", "]", ".", "label", "=", "'channel'", "h5file", "[", "'features'", "]", ".", "dims", "[", "2", "]", ".", "label", "=", "'height'", "h5file", "[", "'features'", "]", ".", "dims", "[", "3", "]", ".", "label", "=", "'width'", "h5file", "[", "'coarse_labels'", "]", ".", "dims", "[", "0", "]", ".", "label", "=", "'batch'", "h5file", "[", "'coarse_labels'", "]", ".", "dims", "[", "1", "]", ".", "label", "=", "'index'", "h5file", "[", "'fine_labels'", "]", ".", "dims", "[", "0", "]", ".", "label", "=", "'batch'", "h5file", "[", "'fine_labels'", "]", ".", "dims", "[", "1", "]", ".", "label", "=", "'index'", "h5file", ".", "flush", "(", ")", "h5file", ".", "close", "(", ")", "return", "(", "output_path", ",", ")" ]
Converts the CIFAR-100 dataset to HDF5. Converts the CIFAR-100 dataset to an HDF5 dataset compatible with :class:`fuel.datasets.CIFAR100`. The converted dataset is saved as 'cifar100.hdf5'. This method assumes the existence of the following file: `cifar-100-python.tar.gz` Parameters ---------- directory : str Directory in which the required input files reside. output_directory : str Directory in which to save the converted dataset. output_filename : str, optional Name of the saved dataset. Defaults to 'cifar100.hdf5'. Returns ------- output_paths : tuple of str Single-element tuple containing the path to the converted dataset.
[ "Converts", "the", "CIFAR", "-", "100", "dataset", "to", "HDF5", "." ]
1d6292dc25e3a115544237e392e61bff6631d23c
https://github.com/mila-iqia/fuel/blob/1d6292dc25e3a115544237e392e61bff6631d23c/fuel/converters/cifar100.py#L15-L95
train