valkey-glide 1.3.5__cp39-cp39-macosx_11_0_arm64.whl → 2.2.2__cp39-cp39-macosx_11_0_arm64.whl

glide_shared/commands/core_options.py

@@ -0,0 +1,407 @@
+# Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from enum import Enum
+from typing import List, Optional, Type, Union, get_args
+
+from glide_shared.commands.command_args import Limit, OrderBy
+from glide_shared.constants import TEncodable
+
+
+@dataclass
+class PubSubMsg:
+    """
+    Describes the incoming pubsub message
+
+    Attributes:
+        message (TEncodable): Incoming message.
+        channel (TEncodable): Name of an channel that triggered the message.
+        pattern (Optional[TEncodable]): Pattern that triggered the message.
+    """
+
+    message: TEncodable
+    channel: TEncodable
+    pattern: Optional[TEncodable]
+
+
+class ConditionalChange(Enum):
+    """
+    A condition to the `SET`, `ZADD` and `GEOADD` commands.
+    """
+
+    ONLY_IF_EXISTS = "XX"
+    """ Only update key / elements that already exist. Equivalent to `XX` in the Valkey API. """
+
+    ONLY_IF_DOES_NOT_EXIST = "NX"
+    """ Only set key / add elements that does not already exist. Equivalent to `NX` in the Valkey API. """
+
+
+class HashFieldConditionalChange(Enum):
+    """
+    Field conditional change options for HSETEX command.
+    """
+
+    ONLY_IF_ALL_EXIST = "FXX"
+    """ Only set fields if all of them already exist. Equivalent to `FXX` in the Valkey API. """
+
+    ONLY_IF_NONE_EXIST = "FNX"
+    """ Only set fields if none of them already exist. Equivalent to `FNX` in the Valkey API. """
+
+
+@dataclass
+class OnlyIfEqual:
+    """
+    Change condition to the `SET` command,
+    For additional conditonal options see ConditionalChange
+
+    - comparison_value - value to compare to the current value of a key.
+
+    If comparison_value is equal to the key, it will overwrite the value of key to the new provided value
+    Equivalent to the IFEQ comparison-value in the Valkey API
+    """
+
+    comparison_value: TEncodable
+
+
+class ExpiryType(Enum):
+    """
+    SET option: The type of the expiry.
+    """
+
+    SEC = 0, Union[int, timedelta]
+    """
+    Set the specified expire time, in seconds. Equivalent to `EX` in the Valkey API.
+    """
+
+    MILLSEC = 1, Union[int, timedelta]
+    """
+    Set the specified expire time, in milliseconds. Equivalent to `PX` in the Valkey API.
+    """
+
+    UNIX_SEC = 2, Union[int, datetime]
+    """
+    Set the specified Unix time at which the key will expire, in seconds. Equivalent to `EXAT` in the Valkey API.
+    """
+
+    UNIX_MILLSEC = 3, Union[int, datetime]
+    """
+    Set the specified Unix time at which the key will expire, in milliseconds. Equivalent to `PXAT` in the Valkey API.
+    """
+
+    KEEP_TTL = 4, Type[None]
+    """
+    Retain the time to live associated with the key. Equivalent to `KEEPTTL` in the Valkey API.
+    """
+
+
+class ExpiryTypeGetEx(Enum):
+    """
+    GetEx option: The type of the expiry.
+    """
+
+    SEC = 0, Union[int, timedelta]
+    """ Set the specified expire time, in seconds. Equivalent to `EX` in the Valkey API. """
+
+    MILLSEC = 1, Union[int, timedelta]
+    """ Set the specified expire time, in milliseconds. Equivalent to `PX` in the Valkey API. """
+
+    UNIX_SEC = 2, Union[int, datetime]
+    """ Set the specified Unix time at which the key will expire, in seconds. Equivalent to `EXAT` in the Valkey API. """
+
+    UNIX_MILLSEC = 3, Union[int, datetime]
+    """ Set the specified Unix time at which the key will expire, in milliseconds. Equivalent to `PXAT` in the Valkey API. """
+
+    PERSIST = 4, Type[None]
+    """ Remove the time to live associated with the key. Equivalent to `PERSIST` in the Valkey API. """
+
+
+class InfoSection(Enum):
+    """
+    INFO option: a specific section of information:
+
+    When no parameter is provided, the default option is assumed.
+    """
+
+    SERVER = "server"
+    """ General information about the server """
+
+    CLIENTS = "clients"
+    """ Client connections section """
+
+    MEMORY = "memory"
+    """ Memory consumption related information """
+
+    PERSISTENCE = "persistence"
+    """ RDB and AOF related information """
+
+    STATS = "stats"
+    """ General statistics """
+
+    REPLICATION = "replication"
+    """ Master/replica replication information """
+
+    CPU = "cpu"
+    """ CPU consumption statistics """
+
+    COMMAND_STATS = "commandstats"
+    """ Valkey command statistics """
+
+    LATENCY_STATS = "latencystats"
+    """ Valkey command latency percentile distribution statistics """
+
+    SENTINEL = "sentinel"
+    """ Valkey Sentinel section (only applicable to Sentinel instances) """
+
+    CLUSTER = "cluster"
+    """ Valkey Cluster section """
+
+    MODULES = "modules"
+    """ Modules section """
+
+    KEYSPACE = "keyspace"
+    """ Database related statistics """
+
+    ERROR_STATS = "errorstats"
+    """ Valkey error statistics """
+
+    ALL = "all"
+    """ Return all sections (excluding module generated ones) """
+
+    DEFAULT = "default"
+    """ Return only the default set of sections """
+
+    EVERYTHING = "everything"
+    """ Includes all and modules """
+
+
+class ExpireOptions(Enum):
+    """
+    EXPIRE option: options for setting key expiry.
+    """
+
+    HasNoExpiry = "NX"
+    """ Set expiry only when the key has no expiry (Equivalent to "NX" in Valkey). """
+
+    HasExistingExpiry = "XX"
+    """ Set expiry only when the key has an existing expiry (Equivalent to "XX" in Valkey). """
+
+    NewExpiryGreaterThanCurrent = "GT"
+    """
+    Set expiry only when the new expiry is greater than the current one (Equivalent to "GT" in Valkey).
+    """
+
+    NewExpiryLessThanCurrent = "LT"
+    """
+    Set expiry only when the new expiry is less than the current one (Equivalent to "LT" in Valkey).
+    """
+
+
+class UpdateOptions(Enum):
+    """
+    Options for updating elements of a sorted set key.
+    """
+
+    LESS_THAN = "LT"
+    """ Only update existing elements if the new score is less than the current score. """
+
+    GREATER_THAN = "GT"
+    """ Only update existing elements if the new score is greater than the current score. """
+
+
+class ExpirySet:
+    """
+    SET option: Represents the expiry type and value to be executed with "SET" command.
+
+    Attributes:
+        cmd_arg (str): The expiry type.
+        value (str): The value for the expiry type.
+    """
+
+    def __init__(
+        self,
+        expiry_type: ExpiryType,
+        value: Optional[Union[int, datetime, timedelta]],
+    ) -> None:
+        self.set_expiry_type_and_value(expiry_type, value)
+
+    def __eq__(self, other: "object") -> bool:
+        if not isinstance(other, ExpirySet):
+            return NotImplemented
+        return self.expiry_type == other.expiry_type and self.value == other.value
+
+    def set_expiry_type_and_value(
+        self, expiry_type: ExpiryType, value: Optional[Union[int, datetime, timedelta]]
+    ):
+        """
+        Args:
+            expiry_type (ExpiryType): The expiry type.
+            value (Optional[Union[int, datetime, timedelta]]): The value of the expiration type. The type of expiration
+                determines the type of expiration value:
+
+                    - SEC: Union[int, timedelta]
+                    - MILLSEC: Union[int, timedelta]
+                    - UNIX_SEC: Union[int, datetime]
+                    - UNIX_MILLSEC: Union[int, datetime]
+                    - KEEP_TTL: Type[None]
+        """
+        if not isinstance(value, get_args(expiry_type.value[1])):
+            raise ValueError(
+                f"The value of {expiry_type} should be of type {expiry_type.value[1]}"
+            )
+        self.expiry_type = expiry_type
+        if self.expiry_type == ExpiryType.SEC:
+            self.cmd_arg = "EX"
+            if isinstance(value, timedelta):
+                value = int(value.total_seconds())
+        elif self.expiry_type == ExpiryType.MILLSEC:
+            self.cmd_arg = "PX"
+            if isinstance(value, timedelta):
+                value = int(value.total_seconds() * 1000)
+        elif self.expiry_type == ExpiryType.UNIX_SEC:
+            self.cmd_arg = "EXAT"
+            if isinstance(value, datetime):
+                value = int(value.timestamp())
+        elif self.expiry_type == ExpiryType.UNIX_MILLSEC:
+            self.cmd_arg = "PXAT"
+            if isinstance(value, datetime):
+                value = int(value.timestamp() * 1000)
+        elif self.expiry_type == ExpiryType.KEEP_TTL:
+            self.cmd_arg = "KEEPTTL"
+        self.value = str(value) if value else None
+
+    def get_cmd_args(self) -> List[str]:
+        return [self.cmd_arg] if self.value is None else [self.cmd_arg, self.value]
+
+
+class ExpiryGetEx:
+    """
+    GetEx option: Represents the expiry type and value to be executed with "GetEx" command.
+
+    Attributes:
+        cmd_arg (str): The expiry type.
+        value (str): The value for the expiry type.
+    """
+
+    def __init__(
+        self,
+        expiry_type: ExpiryTypeGetEx,
+        value: Optional[Union[int, datetime, timedelta]],
+    ) -> None:
+        self.set_expiry_type_and_value(expiry_type, value)
+
+    def set_expiry_type_and_value(
+        self,
+        expiry_type: ExpiryTypeGetEx,
+        value: Optional[Union[int, datetime, timedelta]],
+    ):
+        """
+        Args:
+            expiry_type (ExpiryType): The expiry type.
+            value (Optional[Union[int, datetime, timedelta]]): The value of the expiration type. The type of expiration
+                determines the type of expiration value:
+
+                    - SEC: Union[int, timedelta]
+                    - MILLSEC: Union[int, timedelta]
+                    - UNIX_SEC: Union[int, datetime]
+                    - UNIX_MILLSEC: Union[int, datetime]
+                    - PERSIST: Type[None]
+        """
+        if not isinstance(value, get_args(expiry_type.value[1])):
+            raise ValueError(
+                f"The value of {expiry_type} should be of type {expiry_type.value[1]}"
+            )
+        self.expiry_type = expiry_type
+        if self.expiry_type == ExpiryTypeGetEx.SEC:
+            self.cmd_arg = "EX"
+            if isinstance(value, timedelta):
+                value = int(value.total_seconds())
+        elif self.expiry_type == ExpiryTypeGetEx.MILLSEC:
+            self.cmd_arg = "PX"
+            if isinstance(value, timedelta):
+                value = int(value.total_seconds() * 1000)
+        elif self.expiry_type == ExpiryTypeGetEx.UNIX_SEC:
+            self.cmd_arg = "EXAT"
+            if isinstance(value, datetime):
+                value = int(value.timestamp())
+        elif self.expiry_type == ExpiryTypeGetEx.UNIX_MILLSEC:
+            self.cmd_arg = "PXAT"
+            if isinstance(value, datetime):
+                value = int(value.timestamp() * 1000)
+        elif self.expiry_type == ExpiryTypeGetEx.PERSIST:
+            self.cmd_arg = "PERSIST"
+        self.value = str(value) if value else None
+
+    def get_cmd_args(self) -> List[str]:
+        return [self.cmd_arg] if self.value is None else [self.cmd_arg, self.value]
+
+
+class InsertPosition(Enum):
+    BEFORE = "BEFORE"
+    AFTER = "AFTER"
+
+
+class FlushMode(Enum):
+    """
+    Defines flushing mode for:
+
+    `FLUSHALL` command and `FUNCTION FLUSH` command.
+
+    See [FLUSHAL](https://valkey.io/commands/flushall/) and [FUNCTION-FLUSH](https://valkey.io/commands/function-flush/)
+    for details
+
+    SYNC was introduced in version 6.2.0.
+    """
+
+    ASYNC = "ASYNC"
+    SYNC = "SYNC"
+
+
+class FunctionRestorePolicy(Enum):
+    """
+    Options for the FUNCTION RESTORE command.
+    """
+
+    APPEND = "APPEND"
+    """ Appends the restored libraries to the existing libraries and aborts on collision. This is the default policy. """
+
+    FLUSH = "FLUSH"
+    """ Deletes all existing libraries before restoring the payload. """
+
+    REPLACE = "REPLACE"
+    """
+    Appends the restored libraries to the existing libraries, replacing any existing ones in case
+    of name collisions. Note that this policy doesn't prevent function name collisions, only libraries.
+    """
+
+
+def _build_sort_args(
+    key: TEncodable,
+    by_pattern: Optional[TEncodable] = None,
+    limit: Optional[Limit] = None,
+    get_patterns: Optional[List[TEncodable]] = None,
+    order: Optional[OrderBy] = None,
+    alpha: Optional[bool] = None,
+    store: Optional[TEncodable] = None,
+) -> List[TEncodable]:
+    args = [key]
+
+    if by_pattern:
+        args.extend(["BY", by_pattern])
+
+    if limit:
+        args.extend(["LIMIT", str(limit.offset), str(limit.count)])
+
+    if get_patterns:
+        for pattern in get_patterns:
+            args.extend(["GET", pattern])
+
+    if order:
+        args.append(order.value)
+
+    if alpha:
+        args.append("ALPHA")
+
+    if store:
+        args.extend(["STORE", store])
+
+    return args

{glide/async_commands → glide_shared/commands}/server_modules/ft_options/ft_aggregate_options.py

@@ -1,13 +1,12 @@
 # Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0
 from abc import ABC, abstractmethod
-from enum import Enum
 from typing import List, Mapping, Optional
 
-from glide.async_commands.command_args import OrderBy
-from glide.async_commands.server_modules.ft_options.ft_constants import (
+from glide_shared.commands.command_args import OrderBy
+from glide_shared.commands.server_modules.ft_options.ft_constants import (
     FtAggregateKeywords,
 )
-from glide.constants import TEncodable
+from glide_shared.constants import TEncodable
 
 
 class FtAggregateClause(ABC):
@@ -55,7 +54,8 @@ class FtAggregateLimit(FtAggregateClause):
 
 class FtAggregateFilter(FtAggregateClause):
     """
-    A clause for filtering the results using predicate expression relating to values in each result. It is applied post query and relate to the current state of the pipeline.
+    A clause for filtering the results using predicate expression relating to values in each result. It is applied post query
+    and relate to the current state of the pipeline.
     """
 
     def __init__(self, expression: TEncodable):
@@ -79,7 +79,8 @@ class FtAggregateFilter(FtAggregateClause):
 
 class FtAggregateReducer:
     """
-    A clause for reducing the matching results in each group using a reduction function. The matching results are reduced into a single record.
+    A clause for reducing the matching results in each group using a reduction function. The matching results are reduced into
+    a single record.
     """
 
     def __init__(
@@ -130,7 +131,8 @@ class FtAggregateGroupBy(FtAggregateClause):
 
         Args:
             properties (List[TEncodable]): The list of properties to be used for grouping the results in the pipeline.
-            reducers (List[Reducer]): The list of functions that handles the group entries by performing multiple aggregate operations.
+            reducers (List[Reducer]): The list of functions that handles the group entries by performing multiple
+                aggregate operations.
         """
         self.properties = properties
         self.reducers = reducers
@@ -210,7 +212,8 @@ class FtAggregateSortBy(FtAggregateClause):
 
 class FtAggregateApply(FtAggregateClause):
     """
-    A clause for applying a 1-to-1 transformation on one or more properties and stores the result as a new property down the pipeline or replaces any property using this transformation.
+    A clause for applying a 1-to-1 transformation on one or more properties and stores the result as a new property down the
+    pipeline or replaces any property using this transformation.
     """
 
     def __init__(self, expression: TEncodable, name: TEncodable):
@@ -219,7 +222,8 @@ class FtAggregateApply(FtAggregateClause):
 
         Args:
             expression (TEncodable): The expression to be transformed.
-            name (TEncodable): The new property name to store the result of apply. This name can be referenced by further APPLY/SORTBY/GROUPBY/REDUCE operations down the pipeline.
+            name (TEncodable): The new property name to store the result of apply. This name can be referenced by further
+                APPLY/SORTBY/GROUPBY/REDUCE operations down the pipeline.
         """
         self.expression = expression
         self.name = name
@@ -259,8 +263,11 @@ class FtAggregateOptions:
             loadAll (Optional[bool]): An option to load all fields declared in the index.
             loadFields (Optional[List[TEncodable]]): An option to load only the fields passed in this list.
             timeout (Optional[int]): Overrides the timeout parameter of the module.
-            params (Optional[Mapping[TEncodable, TEncodable]]): The key/value pairs can be referenced from within the query expression.
-            clauses (Optional[List[FtAggregateClause]]): FILTER, LIMIT, GROUPBY, SORTBY and APPLY clauses, that can be repeated multiple times in any order and be freely intermixed. They are applied in the order specified, with the output of one clause feeding the input of the next clause.
+            params (Optional[Mapping[TEncodable, TEncodable]]): The key/value pairs can be referenced from within the
+                query expression.
+            clauses (Optional[List[FtAggregateClause]]): FILTER, LIMIT, GROUPBY, SORTBY and APPLY clauses, that can be
+                repeated multiple times in any order and be freely intermixed. They are applied in the order specified, with
+                the output of one clause feeding the input of the next clause.
         """
         self.loadAll = loadAll
         self.loadFields = loadFields

{glide/async_commands → glide_shared/commands}/server_modules/ft_options/ft_create_options.py

@@ -3,8 +3,10 @@ from abc import ABC, abstractmethod
 from enum import Enum
 from typing import List, Optional
 
-from glide.async_commands.server_modules.ft_options.ft_constants import FtCreateKeywords
-from glide.constants import TEncodable
+from glide_shared.commands.server_modules.ft_options.ft_constants import (
+    FtCreateKeywords,
+)
+from glide_shared.constants import TEncodable
 
 
 class FieldType(Enum):
@@ -159,8 +161,10 @@ class TagField(Field):
         Args:
             name (TEncodable): The name of the tag field.
             alias (Optional[TEncodable]): An alias for the field.
-            separator (Optional[TEncodable]): Specify how text in the attribute is split into individual tags. Must be a single character.
-            case_sensitive (bool): Preserve the original letter cases of tags. If set to False, characters are converted to lowercase by default.
+            separator (Optional[TEncodable]): Specify how text in the attribute is split into individual tags. Must be a
+                single character.
+            case_sensitive (bool): Preserve the original letter cases of tags. If set to False, characters are converted to
+                lowercase by default.
         """
         super().__init__(name, FieldType.TAG, alias)
         self.separator = separator
@@ -209,7 +213,8 @@ class VectorFieldAttributes(ABC):
 
         Args:
             dimensions (int): Number of dimensions in the vector. Equivalent to `DIM` on the module API.
-            distance_metric (DistanceMetricType): The distance metric used in vector type field. Can be one of `[L2 | IP | COSINE]`. Equivalent to `DISTANCE_METRIC` on the module API.
+            distance_metric (DistanceMetricType): The distance metric used in vector type field. Can be one of
+                `[L2 | IP | COSINE]`. Equivalent to `DISTANCE_METRIC` on the module API.
             type (VectorType): Vector type. The only supported type is `FLOAT32`. Equivalent to `TYPE` on the module API.
         """
         self.dimensions = dimensions
@@ -251,9 +256,11 @@ class VectorFieldAttributesFlat(VectorFieldAttributes):
 
         Args:
             dimensions (int): Number of dimensions in the vector. Equivalent to `DIM` on the module API.
-            distance_metric (DistanceMetricType): The distance metric used in vector type field. Can be one of `[L2 | IP | COSINE]`. Equivalent to `DISTANCE_METRIC` on the module API.
+            distance_metric (DistanceMetricType): The distance metric used in vector type field. Can be one of
+                `[L2 | IP | COSINE]`. Equivalent to `DISTANCE_METRIC` on the module API.
             type (VectorType): Vector type. The only supported type is `FLOAT32`. Equivalent to `TYPE` on the module API.
-            initial_cap (Optional[int]): Initial vector capacity in the index affecting memory allocation size of the index. Defaults to `1024`. Equivalent to `INITIAL_CAP` on the module API.
+            initial_cap (Optional[int]): Initial vector capacity in the index affecting memory allocation size of the index.
+                Defaults to `1024`. Equivalent to `INITIAL_CAP` on the module API.
         """
         super().__init__(dimensions, distance_metric, type)
         self.initial_cap = initial_cap
@@ -285,12 +292,18 @@ class VectorFieldAttributesHnsw(VectorFieldAttributes):
 
         Args:
             dimensions (int): Number of dimensions in the vector. Equivalent to `DIM` on the module API.
-            distance_metric (DistanceMetricType): The distance metric used in vector type field. Can be one of `[L2 | IP | COSINE]`. Equivalent to `DISTANCE_METRIC` on the module API.
+            distance_metric (DistanceMetricType): The distance metric used in vector type field. Can be one of
+                `[L2 | IP | COSINE]`. Equivalent to `DISTANCE_METRIC` on the module API.
             type (VectorType): Vector type. The only supported type is `FLOAT32`. Equivalent to `TYPE` on the module API.
-            initial_cap (Optional[int]): Initial vector capacity in the index affecting memory allocation size of the index. Defaults to `1024`. Equivalent to `INITIAL_CAP` on the module API.
-            number_of_edges (Optional[int]): Number of maximum allowed outgoing edges for each node in the graph in each layer. Default is `16`, maximum is `512`. Equivalent to `M` on the module API.
-            vectors_examined_on_construction (Optional[int]): Controls the number of vectors examined during index construction. Default value is `200`, Maximum value is `4096`. Equivalent to `EF_CONSTRUCTION` on the module API.
-            vectors_examined_on_runtime (Optional[int]): Controls the number of vectors examined during query operations. Default value is `10`, Maximum value is `4096`. Equivalent to `EF_RUNTIME` on the module API.
+            initial_cap (Optional[int]): Initial vector capacity in the index affecting memory allocation size of the index.
+                Defaults to `1024`. Equivalent to `INITIAL_CAP` on the module API.
+            number_of_edges (Optional[int]): Number of maximum allowed outgoing edges for each node in the graph in each layer.
+                Default is `16`, maximum is `512`. Equivalent to `M` on the module API.
+            vectors_examined_on_construction (Optional[int]): Controls the number of vectors examined during index
+                construction. Default value is `200`, Maximum value is `4096`. Equivalent to `EF_CONSTRUCTION` on the
+                module API.
+            vectors_examined_on_runtime (Optional[int]): Controls the number of vectors examined during query operations.
+                Default value is `10`, Maximum value is `4096`. Equivalent to `EF_RUNTIME` on the module API.
         """
         super().__init__(dimensions, distance_metric, type)
         self.initial_cap = initial_cap
@@ -337,7 +350,8 @@ class VectorField(Field):
             name (TEncodable): The name of the vector field.
             algorithm (VectorAlgorithm): The vector indexing algorithm.
             alias (Optional[TEncodable]): An alias for the field.
-            attributes (VectorFieldAttributes): Additional attributes to be passed with the vector field after the algorithm name.
+            attributes (VectorFieldAttributes): Additional attributes to be passed with the vector field after the
+                algorithm name.
         """
         super().__init__(name, FieldType.VECTOR, alias)
         self.algorithm = algorithm

{glide/async_commands → glide_shared/commands}/server_modules/ft_options/ft_profile_options.py

@@ -2,16 +2,16 @@
 from enum import Enum
 from typing import List, Optional, Union, cast
 
-from glide.async_commands.server_modules.ft_options.ft_aggregate_options import (
+from glide_shared.commands.server_modules.ft_options.ft_aggregate_options import (
     FtAggregateOptions,
 )
-from glide.async_commands.server_modules.ft_options.ft_constants import (
+from glide_shared.commands.server_modules.ft_options.ft_constants import (
     FtProfileKeywords,
 )
-from glide.async_commands.server_modules.ft_options.ft_search_options import (
+from glide_shared.commands.server_modules.ft_options.ft_search_options import (
     FtSearchOptions,
 )
-from glide.constants import TEncodable
+from glide_shared.constants import TEncodable
 
 
 class QueryType(Enum):
@@ -45,9 +45,11 @@ class FtProfileOptions:
         Initialize a new FtProfileOptions instance.
 
         Args:
-            query (TEncodable): The query that is being profiled. This is the query argument from the FT.AGGREGATE/FT.SEARCH command.
+            query (TEncodable): The query that is being profiled. This is the query argument from the
+                FT.AGGREGATE/FT.SEARCH command.
             query_type (Optional[QueryType]): The type of query to be profiled.
-            query_options (Optional[Union[FtSearchOptions, FtAggregateOptions]]): The arguments/options for the FT.AGGREGATE/FT.SEARCH command being profiled.
+            query_options (Optional[Union[FtSearchOptions, FtAggregateOptions]]): The arguments/options for the
+                FT.AGGREGATE/FT.SEARCH command being profiled.
             limited (Optional[bool]): To provide some brief version of the output, otherwise a full verbose output is provided.
         """
         self.query = query
@@ -66,12 +68,14 @@ class FtProfileOptions:
         A class method to create FtProfileOptions with FT.SEARCH/FT.AGGREGATE options.
 
         Args:
-            query (TEncodable): The query that is being profiled. This is the query argument from the FT.AGGREGATE/FT.SEARCH command.
-            query_options (Optional[Union[FtSearchOptions, FtAggregateOptions]]): The arguments/options for the FT.AGGREGATE/FT.SEARCH command being profiled.
+            query (TEncodable): The query that is being profiled. This is the query argument from the
+                FT.AGGREGATE/FT.SEARCH command.
+            query_options (Optional[Union[FtSearchOptions, FtAggregateOptions]]): The arguments/options for the
+                FT.AGGREGATE/FT.SEARCH command being profiled.
             limited (Optional[bool]): To provide some brief version of the output, otherwise a full verbose output is provided.
         """
         query_type: QueryType = QueryType.SEARCH
-        if type(query_options) == FtAggregateOptions:
+        if isinstance(query_options, FtAggregateOptions):
             query_type = QueryType.AGGREGATE
         return cls(query, query_type, query_options, limited)
 
@@ -83,7 +87,8 @@ class FtProfileOptions:
         A class method to create FtProfileOptions with QueryType.
 
         Args:
-            query (TEncodable): The query that is being profiled. This is the query argument from the FT.AGGREGATE/FT.SEARCH command.
+            query (TEncodable): The query that is being profiled. This is the query argument from the
+                FT.AGGREGATE/FT.SEARCH command.
             query_type (QueryType): The type of query to be profiled.
             limited (Optional[bool]): To provide some brief version of the output, otherwise a full verbose output is provided.
         """
@@ -101,7 +106,7 @@ class FtProfileOptions:
             args.append(FtProfileKeywords.LIMITED)
         args.extend([FtProfileKeywords.QUERY, self.query])
         if self.query_options:
-            if type(self.query_options) == FtAggregateOptions:
+            if isinstance(self.query_options, FtAggregateOptions):
                 args.extend(cast(FtAggregateOptions, self.query_options).to_args())
             else:
                 args.extend(cast(FtSearchOptions, self.query_options).to_args())