def parse_field_str(field_str): """Parses the string representation of a :class:`Field` generated by ``str(field)`` into components that can be passed to :meth:`fiftyone.core.dataset.Dataset.add_sample_field`. Returns: a tuple of - ftype: the :class:`fiftyone.core.fields.Field` class - embedded_doc_type: the :class:`fiftyone.core.odm.BaseEmbeddedDocument` type of the field, or ``None`` - subfield: the :class:`fiftyone.core.fields.Field` class of the subfield, or ``None`` """ chunks = field_str.strip().split("(", 1) ftype = etau.get_class(chunks[0]) embedded_doc_type = None subfield = None if len(chunks) > 1: param = etau.get_class(chunks[1][:-1]) # remove trailing ")" if issubclass(ftype, EmbeddedDocumentField): embedded_doc_type = param elif issubclass(ftype, (ListField, DictField)): subfield = param else: raise ValueError("Failed to parse field string '%s'" % field_str) return ftype, embedded_doc_type, subfield
def parse(class_name, module_name=None): '''Parses a Configurable subclass name string. Assumes both the Configurable class and the Config class are defined in the same module. The module containing the classes will be loaded if necessary. Args: class_name: a string containing the name of the Configurable class, e.g. "ClassName", or a fully-qualified class name, e.g. "eta.core.config.ClassName" module_name: a string containing the fully-qualified module name, e.g. "eta.core.config", or None if class_name includes the module name. Set module_name = __name__ to load a class from the calling module Returns: cls: the Configurable class config_cls: the Config class associated with cls ''' if module_name is None: module_name, class_name = class_name.rsplit(".", 1) cls = etau.get_class(class_name, module_name=module_name) config_cls = etau.get_class( class_name + "Config", module_name=module_name) return cls, config_cls
def _load_dataset(name): try: # pylint: disable=no-member _meta = foo.DatasetDocument.objects.get(name=name) except DoesNotExist: raise DoesNotExistError("Dataset '%s' not found" % name) _sample_doc_cls = type(name, (foo.DatasetSampleDocument,), {}) num_default_fields = len(foos.default_sample_fields(include_private=True)) for sample_field in _meta.sample_fields[num_default_fields:]: subfield = ( etau.get_class(sample_field.subfield) if sample_field.subfield else None ) embedded_doc_type = ( etau.get_class(sample_field.embedded_doc_type) if sample_field.embedded_doc_type else None ) _sample_doc_cls.add_field( sample_field.name, etau.get_class(sample_field.ftype), subfield=subfield, embedded_doc_type=embedded_doc_type, save=False, ) return _meta, _sample_doc_cls
def execute(parser, args): input_dir = args.input_dir input_type = etau.get_class(args.input_type) output_dir = args.output_dir output_type = etau.get_class(args.output_type) foud.convert_dataset( input_dir=input_dir, input_type=input_type, output_dir=output_dir, output_type=output_type, )
def execute(parser, args): if args.zoo_dataset: # View a zoo dataset name = args.zoo_dataset splits = args.splits dataset_dir = args.dataset_dir dataset = foz.load_zoo_dataset(name, splits=splits, dataset_dir=dataset_dir) elif args.dataset_dir: # View a dataset from a directory name = args.name dataset_dir = args.dataset_dir dataset_type = etau.get_class(args.type) dataset = fod.Dataset.from_dir(dataset_dir, dataset_type, name=name) elif args.json_path: # View a dataset from a JSON file name = args.name json_path = args.json_path dataset = fod.Dataset.from_json(json_path, name=name) else: raise ValueError( "Either `zoo_dataset`, `dataset_dir`, or `json_path` must be " "provided") session = fos.launch_app(dataset=dataset, port=args.port, remote=args.remote) _watch_session(session, remote=args.remote)
def execute(parser, args): if args.zoo_dataset: # View a zoo dataset name = args.zoo_dataset splits = args.splits dataset_dir = args.dataset_dir kwargs = _parse_dataset_import_kwargs(args) dataset = foz.load_zoo_dataset(name, splits=splits, dataset_dir=dataset_dir, **kwargs) elif args.dataset_dir: # View a dataset from a directory name = args.name dataset_dir = args.dataset_dir dataset_type = etau.get_class(args.type) kwargs = _parse_dataset_import_kwargs(args) dataset = fod.Dataset.from_dir(dataset_dir, dataset_type, name=name, **kwargs) elif args.images_dir: # View a directory of images name = args.name images_dir = args.images_dir dataset = fod.Dataset.from_images_dir(images_dir, name=name) elif args.images_patt: # View a glob pattern of images name = args.name images_patt = args.images_patt dataset = fod.Dataset.from_images_patt(images_patt, name=name) elif args.videos_dir: # View a directory of images name = args.name videos_dir = args.videos_dir dataset = fod.Dataset.from_videos_dir(videos_dir, name=name) elif args.videos_patt: # View a glob pattern of videos name = args.name videos_patt = args.videos_patt dataset = fod.Dataset.from_videos_patt(videos_patt, name=name) elif args.json_path: # View a dataset from a JSON file name = args.name json_path = args.json_path dataset = fod.Dataset.from_json(json_path, name=name) else: raise ValueError( "Either `zoo_dataset`, `dataset_dir`, or `json_path` must be " "provided") session = fos.launch_app(dataset=dataset, port=args.port, remote=args.remote) _watch_session(session, remote=args.remote)
def from_dict(cls, d): """Loads a :class:`ZooDatasetInfo` from a JSON dictionary. Args: d: a JSON dictionary Returns: a :class:`ZooDatasetInfo` """ try: # @legacy field name zoo_dataset = d["zoo_dataset_cls"] except KeyError: zoo_dataset = d["zoo_dataset"] try: # @legacy field name dataset_type = d["format_cls"] except KeyError: dataset_type = d["dataset_type"] # @legacy dataset types _dt = "fiftyone.types.dataset_types" if dataset_type.endswith(".ImageClassificationDataset"): dataset_type = _dt + ".FiftyOneImageClassificationDataset" if dataset_type.endswith(".ImageDetectionDataset"): dataset_type = _dt + ".FiftyOneImageDetectionDataset" zoo_dataset = etau.get_class(zoo_dataset)() dataset_type = etau.get_class(dataset_type)() downloaded_splits = d.get("downloaded_splits", None) if downloaded_splits is not None: downloaded_splits = { k: ZooDatasetSplitInfo.from_dict(v) for k, v in downloaded_splits.items() } return cls( zoo_dataset, dataset_type, d["num_samples"], downloaded_splits=downloaded_splits, classes=d.get("classes", None), )
def _from_dict(cls, d): """Creates a :class:`ViewStage` instance from a serialized JSON dict representation of it. Args: d: a JSON dict Returns: a :class:`ViewStage` """ view_stage_cls = etau.get_class(d["_cls"]) return view_stage_cls(**{k: v for (k, v) in d["kwargs"]})
def from_dict(cls, d): '''Constructs a Container from a JSON dictionary. If the dictionary has the `"_CLS"` and `cls._ELE_CLS_FIELD` keys, they are used to infer the Container class and underlying element classes, respectively, and this method can be invoked on any `Container` subclass that has the same `_ELE_CLS_FIELD` setting. Otherwise, this method must be called on the same concrete `Container` subclass from which the JSON was generated. ''' if cls._ELE_CLS_FIELD is None: raise ContainerError( "%s is an abstract container and cannot be used to load a " "JSON dictionary. Please use a Container subclass that " "defines its `_ELE_CLS_FIELD` member" % cls) if "_CLS" in d: if cls._ELE_CLS_FIELD not in d: raise ContainerError( "Cannot use %s to reflectively load this container " "because the expected field '%s' was not found in the " "JSON dictionary" % (cls, cls._ELE_CLS_FIELD)) # Parse reflectively cls = etau.get_class(d["_CLS"]) ele_cls = etau.get_class(d[cls._ELE_CLS_FIELD]) else: # Validates the cls settings cls() # Parse using provided class ele_cls = cls._ELE_CLS return cls(**{ cls._ELE_ATTR: [ele_cls.from_dict(dd) for dd in d[cls._ELE_ATTR]] })
def parse_type(type_str): '''Parses the type string and returns the associated Type. Raises: TypeError: is the type string was not a recognized type ''' try: type_cls = etau.get_class(type_str) except ImportError: raise TypeError("Unknown type '%s'" % type_str) if not issubclass(type_cls, Type): raise TypeError("Type '%s' must be a subclass of Type" % type_cls) return type_cls
def execute(parser, args): name = args.name dataset_dir = args.dataset_dir json_path = args.json_path dataset_type = etau.get_class(args.type) if args.type else None if dataset_dir: dataset = fod.Dataset.from_dir(dataset_dir, dataset_type, name=name) elif json_path: dataset = fod.Dataset.from_json(json_path, name=name) else: raise ValueError( "Either `dataset_dir` or `json_path` must be provided") dataset.persistent = True print("Dataset '%s' created" % dataset.name)
def execute(parser, args): name = args.name export_dir = args.export_dir json_path = args.json_path label_field = args.label_field dataset_type = etau.get_class(args.type) if args.type else None dataset = fod.load_dataset(name) if export_dir: dataset.export(export_dir, label_field=label_field, dataset_type=dataset_type) print("Dataset '%s' exported to '%s'" % (name, export_dir)) elif json_path: dataset.write_json(json_path) print("Dataset '%s' exported to '%s'" % (name, json_path)) else: raise ValueError( "Either `export_dir` or `json_path` must be provided")