<!-- # hard line break macro for HTML -->

# fiftyone.operators.utils

FiftyOne operator utilities.

Copyright 2017-2026, Voxel51, Inc.
<br/>
[voxel51.com](https://voxel51.com/)
<br/>
<br/>

**Classes:**

| [`ProgressHandler`](#fiftyone.operators.utils.ProgressHandler)(ctx[, logger, level])   | A logging handler that reports all logging messages issued while the handler's context manager is active to the provided execution context's [`set_progress()`](fiftyone.operators.executor.md#fiftyone.operators.executor.ExecutionContext.set_progress) method.   |
|----------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

**Functions:**

| [`is_method_overridden`](#fiftyone.operators.utils.is_method_overridden)(base_class, ...)   | Returns whether a method is overridden in a subclass.                                                                                                                                                                                                                        |
|---------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [`is_new`](#fiftyone.operators.utils.is_new)(release_date[, days])                          | Determines if a feature is considered "new" based on its release date.                                                                                                                                                                                                       |
| [`create_operator_response`](#fiftyone.operators.utils.create_operator_response)(result)    | Creates a `starlette.responses.JSONResponse` from the given [`fiftyone.operators.executor.ExecutionResult`](fiftyone.operators.executor.md#fiftyone.operators.executor.ExecutionResult) or returns a server error `starlette.responses.JSONResponse` if serialization fails. |

### *class* fiftyone.operators.utils.ProgressHandler(ctx, logger=None, level=None)

Bases: `Handler`

A logging handler that reports all logging messages issued while the
handler’s context manager is active to the provided execution context’s
[`set_progress()`](fiftyone.operators.executor.md#fiftyone.operators.executor.ExecutionContext.set_progress)
method.

* **Parameters:**
  * **ctx** – an [`fiftyone.operators.executor.ExecutionContext`](fiftyone.operators.executor.md#fiftyone.operators.executor.ExecutionContext)
  * **logger** (*None*) – a specific `logging.Logger` for which to report
    records. By default, the root logger is used
  * **level** (*None*) – an optional logging level above which to report records.
    By default, the logger’s effective level is used

**Methods:**

| [`emit`](#fiftyone.operators.utils.ProgressHandler.emit)(record)                 | Do whatever it takes to actually log the specified logging record.   |
|----------------------------------------------------------------------------------|----------------------------------------------------------------------|
| [`acquire`](#fiftyone.operators.utils.ProgressHandler.acquire)()                 | Acquire the I/O thread lock.                                         |
| [`addFilter`](#fiftyone.operators.utils.ProgressHandler.addFilter)(filter)       | Add the specified filter to this handler.                            |
| [`close`](#fiftyone.operators.utils.ProgressHandler.close)()                     | Tidy up any resources used by the handler.                           |
| [`createLock`](#fiftyone.operators.utils.ProgressHandler.createLock)()           | Acquire a thread lock for serializing access to the underlying I/O.  |
| [`filter`](#fiftyone.operators.utils.ProgressHandler.filter)(record)             | Determine if a record is loggable by consulting all the filters.     |
| [`flush`](#fiftyone.operators.utils.ProgressHandler.flush)()                     | Ensure all logging output has been flushed.                          |
| [`format`](#fiftyone.operators.utils.ProgressHandler.format)(record)             | Format the specified record.                                         |
| [`get_name`](#fiftyone.operators.utils.ProgressHandler.get_name)()               |                                                                      |
| [`handle`](#fiftyone.operators.utils.ProgressHandler.handle)(record)             | Conditionally emit the specified logging record.                     |
| [`handleError`](#fiftyone.operators.utils.ProgressHandler.handleError)(record)   | Handle errors which occur during an emit() call.                     |
| [`release`](#fiftyone.operators.utils.ProgressHandler.release)()                 | Release the I/O thread lock.                                         |
| [`removeFilter`](#fiftyone.operators.utils.ProgressHandler.removeFilter)(filter) | Remove the specified filter from this handler.                       |
| [`setFormatter`](#fiftyone.operators.utils.ProgressHandler.setFormatter)(fmt)    | Set the formatter for this handler.                                  |
| [`setLevel`](#fiftyone.operators.utils.ProgressHandler.setLevel)(level)          | Set the logging level of this handler.                               |
| [`set_name`](#fiftyone.operators.utils.ProgressHandler.set_name)(name)           |                                                                      |

**Attributes:**

| [`name`](#fiftyone.operators.utils.ProgressHandler.name)   |    |
|------------------------------------------------------------|----|

#### emit(record)

Do whatever it takes to actually log the specified logging record.

This version is intended to be implemented by subclasses and so
raises a NotImplementedError.

#### acquire()

Acquire the I/O thread lock.

#### addFilter(filter)

Add the specified filter to this handler.

#### close()

Tidy up any resources used by the handler.

This version removes the handler from an internal map of handlers,
\_handlers, which is used for handler lookup by name. Subclasses
should ensure that this gets called from overridden close()
methods.

#### createLock()

Acquire a thread lock for serializing access to the underlying I/O.

#### filter(record)

Determine if a record is loggable by consulting all the filters.

The default is to allow the record to be logged; any filter can veto
this by returning a false value.
If a filter attached to a handler returns a log record instance,
then that instance is used in place of the original log record in
any further processing of the event by that handler.
If a filter returns any other true value, the original log record
is used in any further processing of the event by that handler.

If none of the filters return false values, this method returns
a log record.
If any of the filters return a false value, this method returns
a false value.

#### Versionchanged
Changed in version 3.2: Allow filters to be just callables.

#### Versionchanged
Changed in version 3.12: Allow filters to return a LogRecord instead of
modifying it in place.

#### flush()

Ensure all logging output has been flushed.

This version does nothing and is intended to be implemented by
subclasses.

#### format(record)

Format the specified record.

If a formatter is set, use it. Otherwise, use the default formatter
for the module.

#### get_name()

#### handle(record)

Conditionally emit the specified logging record.

Emission depends on filters which may have been added to the handler.
Wrap the actual emission of the record with acquisition/release of
the I/O thread lock.

Returns an instance of the log record that was emitted
if it passed all filters, otherwise a false value is returned.

#### handleError(record)

Handle errors which occur during an emit() call.

This method should be called from handlers when an exception is
encountered during an emit() call. If raiseExceptions is false,
exceptions get silently ignored. This is what is mostly wanted
for a logging system - most users will not care about errors in
the logging system, they are more interested in application errors.
You could, however, replace this with a custom handler if you wish.
The record which was being processed is passed in to this method.

#### *property* name

#### release()

Release the I/O thread lock.

#### removeFilter(filter)

Remove the specified filter from this handler.

#### setFormatter(fmt)

Set the formatter for this handler.

#### setLevel(level)

Set the logging level of this handler.  level must be an int or a str.

#### set_name(name)

### fiftyone.operators.utils.is_method_overridden(base_class, sub_class_instance, method_name)

Returns whether a method is overridden in a subclass.

* **Parameters:**
  * **base_class** – the base class
  * **sub_class_instance** – an instance of the subclass
  * **method_name** – the name of the method
* **Returns:**
  True/False

### fiftyone.operators.utils.is_new(release_date, days=30)

Determines if a feature is considered “new” based on its release date.

A feature is considered new if its release date is within the specified
number of days.

Examples:

```default
is_new("2024-11-09")
# True if today's date is within 30 days after 2024-11-09

is_new(datetime(2024, 11, 9), days=15)
# True if today's date is within 15 days after November 9, 2024

is_new("2024-10-01", days=45)
# False if today's date is more than 45 days after October 1, 2024
```

* **Parameters:**
  * **release_date** – 

    the release date of the feature, in one of the following
    formats:
    - a string in the format `"%Y-%m-%d"`, e.g., `"2024-11-09"`
    - a datetime instance
  * **days** (*30*) – the number of days for which the feature is considered new
* **Returns:**
  True/False whether the release date is within the specified number of
  days

### *async* fiftyone.operators.utils.create_operator_response(result: [ExecutionResult](fiftyone.operators.executor.md#fiftyone.operators.executor.ExecutionResult)) → Response | JSONResponse

Creates a `starlette.responses.JSONResponse` from the given
[`fiftyone.operators.executor.ExecutionResult`](fiftyone.operators.executor.md#fiftyone.operators.executor.ExecutionResult) or returns a
server error `starlette.responses.JSONResponse` if serialization fails.

* **Parameters:**
  **result** – the operator execution result
* **Returns:**
  `starlette.responses.Response` or
  `starlette.responses.JSONResponse`