body
stringlengths 26
98.2k
| body_hash
int64 -9,222,864,604,528,158,000
9,221,803,474B
| docstring
stringlengths 1
16.8k
| path
stringlengths 5
230
| name
stringlengths 1
96
| repository_name
stringlengths 7
89
| lang
stringclasses 1
value | body_without_docstring
stringlengths 20
98.2k
|
|---|---|---|---|---|---|---|---|
def import_user_events(self, request: Union[(import_.ImportUserEventsRequest, dict)]=None, *, parent: str=None, request_id: str=None, input_config: import_.InputConfig=None, errors_config: import_.ImportErrorsConfig=None, retry: retries.Retry=gapic_v1.method.DEFAULT, timeout: float=None, metadata: Sequence[Tuple[(str, str)]]=()) -> operation.Operation:
'Bulk import of User events. Request processing might\n be synchronous. Events that already exist are skipped.\n Use this method for backfilling historical user events.\n Operation.response is of type ImportResponse. Note that\n it is possible for a subset of the items to be\n successfully inserted. Operation.metadata is of type\n ImportMetadata.\n\n Args:\n request (Union[google.cloud.recommendationengine_v1beta1.types.ImportUserEventsRequest, dict]):\n The request object. Request message for the\n ImportUserEvents request.\n parent (str):\n Required.\n ``projects/1234/locations/global/catalogs/default_catalog/eventStores/default_event_store``\n\n This corresponds to the ``parent`` field\n on the ``request`` instance; if ``request`` is provided, this\n should not be set.\n request_id (str):\n Optional. Unique identifier provided by client, within\n the ancestor dataset scope. Ensures idempotency for\n expensive long running operations. Server-generated if\n unspecified. Up to 128 characters long. This is returned\n as google.longrunning.Operation.name in the response.\n Note that this field must not be set if the desired\n input config is catalog_inline_source.\n\n This corresponds to the ``request_id`` field\n on the ``request`` instance; if ``request`` is provided, this\n should not be set.\n input_config (google.cloud.recommendationengine_v1beta1.types.InputConfig):\n Required. The desired input location\n of the data.\n\n This corresponds to the ``input_config`` field\n on the ``request`` instance; if ``request`` is provided, this\n should not be set.\n errors_config (google.cloud.recommendationengine_v1beta1.types.ImportErrorsConfig):\n Optional. The desired location of\n errors incurred during the Import.\n\n This corresponds to the ``errors_config`` field\n on the ``request`` instance; if ``request`` is provided, this\n should not be set.\n retry (google.api_core.retry.Retry): Designation of what errors, if any,\n should be retried.\n timeout (float): The timeout for this request.\n metadata (Sequence[Tuple[str, str]]): Strings which should be\n sent along with the request as metadata.\n\n Returns:\n google.api_core.operation.Operation:\n An object representing a long-running operation.\n\n The result type for the operation will be :class:`google.cloud.recommendationengine_v1beta1.types.ImportUserEventsResponse` Response of the ImportUserEventsRequest. If the long running\n operation was successful, then this message is\n returned by the\n google.longrunning.Operations.response field if the\n operation was successful.\n\n '
has_flattened_params = any([parent, request_id, input_config, errors_config])
if ((request is not None) and has_flattened_params):
raise ValueError('If the `request` argument is set, then none of the individual field arguments should be set.')
if (not isinstance(request, import_.ImportUserEventsRequest)):
request = import_.ImportUserEventsRequest(request)
if (parent is not None):
request.parent = parent
if (request_id is not None):
request.request_id = request_id
if (input_config is not None):
request.input_config = input_config
if (errors_config is not None):
request.errors_config = errors_config
rpc = self._transport._wrapped_methods[self._transport.import_user_events]
metadata = (tuple(metadata) + (gapic_v1.routing_header.to_grpc_metadata((('parent', request.parent),)),))
response = rpc(request, retry=retry, timeout=timeout, metadata=metadata)
response = operation.from_gapic(response, self._transport.operations_client, import_.ImportUserEventsResponse, metadata_type=import_.ImportMetadata)
return response
| -65,562,314,620,787,490
|
Bulk import of User events. Request processing might
be synchronous. Events that already exist are skipped.
Use this method for backfilling historical user events.
Operation.response is of type ImportResponse. Note that
it is possible for a subset of the items to be
successfully inserted. Operation.metadata is of type
ImportMetadata.
Args:
request (Union[google.cloud.recommendationengine_v1beta1.types.ImportUserEventsRequest, dict]):
The request object. Request message for the
ImportUserEvents request.
parent (str):
Required.
``projects/1234/locations/global/catalogs/default_catalog/eventStores/default_event_store``
This corresponds to the ``parent`` field
on the ``request`` instance; if ``request`` is provided, this
should not be set.
request_id (str):
Optional. Unique identifier provided by client, within
the ancestor dataset scope. Ensures idempotency for
expensive long running operations. Server-generated if
unspecified. Up to 128 characters long. This is returned
as google.longrunning.Operation.name in the response.
Note that this field must not be set if the desired
input config is catalog_inline_source.
This corresponds to the ``request_id`` field
on the ``request`` instance; if ``request`` is provided, this
should not be set.
input_config (google.cloud.recommendationengine_v1beta1.types.InputConfig):
Required. The desired input location
of the data.
This corresponds to the ``input_config`` field
on the ``request`` instance; if ``request`` is provided, this
should not be set.
errors_config (google.cloud.recommendationengine_v1beta1.types.ImportErrorsConfig):
Optional. The desired location of
errors incurred during the Import.
This corresponds to the ``errors_config`` field
on the ``request`` instance; if ``request`` is provided, this
should not be set.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
google.api_core.operation.Operation:
An object representing a long-running operation.
The result type for the operation will be :class:`google.cloud.recommendationengine_v1beta1.types.ImportUserEventsResponse` Response of the ImportUserEventsRequest. If the long running
operation was successful, then this message is
returned by the
google.longrunning.Operations.response field if the
operation was successful.
|
google/cloud/recommendationengine/v1beta1/recommendationengine-v1beta1-py/google/cloud/recommendationengine_v1beta1/services/user_event_service/client.py
|
import_user_events
|
googleapis/googleapis-gen
|
python
|
def import_user_events(self, request: Union[(import_.ImportUserEventsRequest, dict)]=None, *, parent: str=None, request_id: str=None, input_config: import_.InputConfig=None, errors_config: import_.ImportErrorsConfig=None, retry: retries.Retry=gapic_v1.method.DEFAULT, timeout: float=None, metadata: Sequence[Tuple[(str, str)]]=()) -> operation.Operation:
'Bulk import of User events. Request processing might\n be synchronous. Events that already exist are skipped.\n Use this method for backfilling historical user events.\n Operation.response is of type ImportResponse. Note that\n it is possible for a subset of the items to be\n successfully inserted. Operation.metadata is of type\n ImportMetadata.\n\n Args:\n request (Union[google.cloud.recommendationengine_v1beta1.types.ImportUserEventsRequest, dict]):\n The request object. Request message for the\n ImportUserEvents request.\n parent (str):\n Required.\n ``projects/1234/locations/global/catalogs/default_catalog/eventStores/default_event_store``\n\n This corresponds to the ``parent`` field\n on the ``request`` instance; if ``request`` is provided, this\n should not be set.\n request_id (str):\n Optional. Unique identifier provided by client, within\n the ancestor dataset scope. Ensures idempotency for\n expensive long running operations. Server-generated if\n unspecified. Up to 128 characters long. This is returned\n as google.longrunning.Operation.name in the response.\n Note that this field must not be set if the desired\n input config is catalog_inline_source.\n\n This corresponds to the ``request_id`` field\n on the ``request`` instance; if ``request`` is provided, this\n should not be set.\n input_config (google.cloud.recommendationengine_v1beta1.types.InputConfig):\n Required. The desired input location\n of the data.\n\n This corresponds to the ``input_config`` field\n on the ``request`` instance; if ``request`` is provided, this\n should not be set.\n errors_config (google.cloud.recommendationengine_v1beta1.types.ImportErrorsConfig):\n Optional. The desired location of\n errors incurred during the Import.\n\n This corresponds to the ``errors_config`` field\n on the ``request`` instance; if ``request`` is provided, this\n should not be set.\n retry (google.api_core.retry.Retry): Designation of what errors, if any,\n should be retried.\n timeout (float): The timeout for this request.\n metadata (Sequence[Tuple[str, str]]): Strings which should be\n sent along with the request as metadata.\n\n Returns:\n google.api_core.operation.Operation:\n An object representing a long-running operation.\n\n The result type for the operation will be :class:`google.cloud.recommendationengine_v1beta1.types.ImportUserEventsResponse` Response of the ImportUserEventsRequest. If the long running\n operation was successful, then this message is\n returned by the\n google.longrunning.Operations.response field if the\n operation was successful.\n\n '
has_flattened_params = any([parent, request_id, input_config, errors_config])
if ((request is not None) and has_flattened_params):
raise ValueError('If the `request` argument is set, then none of the individual field arguments should be set.')
if (not isinstance(request, import_.ImportUserEventsRequest)):
request = import_.ImportUserEventsRequest(request)
if (parent is not None):
request.parent = parent
if (request_id is not None):
request.request_id = request_id
if (input_config is not None):
request.input_config = input_config
if (errors_config is not None):
request.errors_config = errors_config
rpc = self._transport._wrapped_methods[self._transport.import_user_events]
metadata = (tuple(metadata) + (gapic_v1.routing_header.to_grpc_metadata((('parent', request.parent),)),))
response = rpc(request, retry=retry, timeout=timeout, metadata=metadata)
response = operation.from_gapic(response, self._transport.operations_client, import_.ImportUserEventsResponse, metadata_type=import_.ImportMetadata)
return response
|
def __exit__(self, type, value, traceback):
"Releases underlying transport's resources.\n\n .. warning::\n ONLY use as a context manager if the transport is NOT shared\n with other clients! Exiting the with block will CLOSE the transport\n and may cause errors in other clients!\n "
self.transport.close()
| 7,840,855,355,632,227,000
|
Releases underlying transport's resources.
.. warning::
ONLY use as a context manager if the transport is NOT shared
with other clients! Exiting the with block will CLOSE the transport
and may cause errors in other clients!
|
google/cloud/recommendationengine/v1beta1/recommendationengine-v1beta1-py/google/cloud/recommendationengine_v1beta1/services/user_event_service/client.py
|
__exit__
|
googleapis/googleapis-gen
|
python
|
def __exit__(self, type, value, traceback):
"Releases underlying transport's resources.\n\n .. warning::\n ONLY use as a context manager if the transport is NOT shared\n with other clients! Exiting the with block will CLOSE the transport\n and may cause errors in other clients!\n "
self.transport.close()
|
def __init__(self, switch_configuration, terminal_controller, logger, piping_processor):
'\n :type switch_configuration: fake_switches.switch_configuration.SwitchConfiguration\n :type terminal_controller: fake_switches.terminal.TerminalController\n :type logger: logging.Logger\n :type piping_processor: fake_switches.command_processing.piping_processor_base.PipingProcessorBase\n '
self.switch_configuration = switch_configuration
self.terminal_controller = terminal_controller
self.logger = logger
self.piping_processor = piping_processor
self.sub_processor = None
self.continuing_to = None
self.is_done = False
self.replace_input = False
self.awaiting_keystroke = False
| 4,927,496,851,383,046,000
|
:type switch_configuration: fake_switches.switch_configuration.SwitchConfiguration
:type terminal_controller: fake_switches.terminal.TerminalController
:type logger: logging.Logger
:type piping_processor: fake_switches.command_processing.piping_processor_base.PipingProcessorBase
|
fake_switches/command_processing/base_command_processor.py
|
__init__
|
idjaw/fake-switches
|
python
|
def __init__(self, switch_configuration, terminal_controller, logger, piping_processor):
'\n :type switch_configuration: fake_switches.switch_configuration.SwitchConfiguration\n :type terminal_controller: fake_switches.terminal.TerminalController\n :type logger: logging.Logger\n :type piping_processor: fake_switches.command_processing.piping_processor_base.PipingProcessorBase\n '
self.switch_configuration = switch_configuration
self.terminal_controller = terminal_controller
self.logger = logger
self.piping_processor = piping_processor
self.sub_processor = None
self.continuing_to = None
self.is_done = False
self.replace_input = False
self.awaiting_keystroke = False
|
@staticmethod
def div(p, q):
'\n ``p / q`` returning the correct infinity instead of\n raising ZeroDivisionError.\n '
from math import copysign
if (q != 0.0):
return (p / q)
elif (p == 0.0):
return (p / q)
elif (copysign(1, q) > 0):
return copysign(inf, p)
else:
return copysign(inf, (- p))
| -7,729,998,379,710,486,000
|
``p / q`` returning the correct infinity instead of
raising ZeroDivisionError.
|
inf.py
|
div
|
sensiblecodeio/inf
|
python
|
@staticmethod
def div(p, q):
'\n ``p / q`` returning the correct infinity instead of\n raising ZeroDivisionError.\n '
from math import copysign
if (q != 0.0):
return (p / q)
elif (p == 0.0):
return (p / q)
elif (copysign(1, q) > 0):
return copysign(inf, p)
else:
return copysign(inf, (- p))
|
def search_gdf_polygon(gdf, tile_polygon):
"Find polygons in a GeoDataFrame that overlap with `tile_polygon` .\n\n Arguments\n ---------\n gdf : :py:class:`geopandas.GeoDataFrame`\n A :py:class:`geopandas.GeoDataFrame` of polygons to search.\n tile_polygon : :py:class:`shapely.geometry.Polygon`\n A :py:class:`shapely.geometry.Polygon` denoting a tile's bounds.\n\n Returns\n -------\n precise_matches : :py:class:`geopandas.GeoDataFrame`\n The subset of `gdf` that overlaps with `tile_polygon` . If\n there are no overlaps, this will return an empty\n :py:class:`geopandas.GeoDataFrame`.\n\n "
sindex = gdf.sindex
possible_matches_index = list(sindex.intersection(tile_polygon.bounds))
possible_matches = gdf.iloc[possible_matches_index]
precise_matches = possible_matches[possible_matches.intersects(tile_polygon)]
if precise_matches.empty:
precise_matches = gpd.GeoDataFrame(geometry=[])
return precise_matches
| -949,607,495,950,691,700
|
Find polygons in a GeoDataFrame that overlap with `tile_polygon` .
Arguments
---------
gdf : :py:class:`geopandas.GeoDataFrame`
A :py:class:`geopandas.GeoDataFrame` of polygons to search.
tile_polygon : :py:class:`shapely.geometry.Polygon`
A :py:class:`shapely.geometry.Polygon` denoting a tile's bounds.
Returns
-------
precise_matches : :py:class:`geopandas.GeoDataFrame`
The subset of `gdf` that overlaps with `tile_polygon` . If
there are no overlaps, this will return an empty
:py:class:`geopandas.GeoDataFrame`.
|
3-SatShipAI/solaris/tile/vector_tile.py
|
search_gdf_polygon
|
CosmiQ/SpaceNet_SAR_Buildings_Solutions
|
python
|
def search_gdf_polygon(gdf, tile_polygon):
"Find polygons in a GeoDataFrame that overlap with `tile_polygon` .\n\n Arguments\n ---------\n gdf : :py:class:`geopandas.GeoDataFrame`\n A :py:class:`geopandas.GeoDataFrame` of polygons to search.\n tile_polygon : :py:class:`shapely.geometry.Polygon`\n A :py:class:`shapely.geometry.Polygon` denoting a tile's bounds.\n\n Returns\n -------\n precise_matches : :py:class:`geopandas.GeoDataFrame`\n The subset of `gdf` that overlaps with `tile_polygon` . If\n there are no overlaps, this will return an empty\n :py:class:`geopandas.GeoDataFrame`.\n\n "
sindex = gdf.sindex
possible_matches_index = list(sindex.intersection(tile_polygon.bounds))
possible_matches = gdf.iloc[possible_matches_index]
precise_matches = possible_matches[possible_matches.intersects(tile_polygon)]
if precise_matches.empty:
precise_matches = gpd.GeoDataFrame(geometry=[])
return precise_matches
|
def clip_gdf(gdf, tile_bounds, min_partial_perc=0.0, geom_type='Polygon', use_sindex=True, verbose=False):
'Clip GDF to a provided polygon.\n\n Clips objects within `gdf` to the region defined by\n `poly_to_cut`. Also adds several columns to the output::\n\n `origarea`\n The original area of the polygons (only used if `geom_type` ==\n ``"Polygon"``).\n `origlen`\n The original length of the objects (only used if `geom_type` ==\n ``"LineString"``).\n `partialDec`\n The fraction of the object that remains after clipping\n (fraction of area for Polygons, fraction of length for\n LineStrings.) Can filter based on this by using `min_partial_perc`.\n `truncated`\n Boolean indicator of whether or not an object was clipped.\n\n Arguments\n ---------\n gdf : :py:class:`geopandas.GeoDataFrame`\n A :py:class:`geopandas.GeoDataFrame` of polygons to clip.\n tile_bounds : `list` or :class:`shapely.geometry.Polygon`\n The geometry to clip objects in `gdf` to. This can either be a\n ``[left, top, right, bottom] `` bounds list or a\n :class:`shapely.geometry.Polygon` object defining the area to keep.\n min_partial_perc : float, optional\n The minimum fraction of an object in `gdf` that must be\n preserved. Defaults to 0.0 (include any object if any part remains\n following clipping).\n geom_type : str, optional\n Type of objects in `gdf`. Can be one of\n ``["Polygon", "LineString"]`` . Defaults to ``"Polygon"`` .\n use_sindex : bool, optional\n Use the `gdf` sindex be used for searching. Improves efficiency\n but requires `libspatialindex <http://libspatialindex.github.io/>`__ .\n verbose : bool, optional\n Switch to print relevant values.\n\n Returns\n -------\n cut_gdf : :py:class:`geopandas.GeoDataFrame`\n `gdf` with all contained objects clipped to `poly_to_cut` .\n See notes above for details on additional clipping columns added.\n\n '
if isinstance(tile_bounds, tuple):
tb = box(*tile_bounds)
elif isinstance(tile_bounds, list):
tb = box(*tile_bounds)
elif isinstance(tile_bounds, Polygon):
tb = tile_bounds
if (use_sindex and (geom_type == 'Polygon')):
gdf = search_gdf_polygon(gdf, tb)
if ('origarea' in gdf.columns):
pass
elif ('geom_type' == 'LineString'):
gdf['origarea'] = 0
else:
gdf['origarea'] = gdf.area
if ('origlen' in gdf.columns):
pass
elif ('geom_type' == 'LineString'):
gdf['origlen'] = gdf.length
else:
gdf['origlen'] = 0
cut_gdf = gdf.copy()
cut_gdf.geometry = gdf.intersection(tb)
if (geom_type == 'Polygon'):
cut_gdf['partialDec'] = (cut_gdf.area / cut_gdf['origarea'])
cut_gdf = cut_gdf.loc[(cut_gdf['partialDec'] > min_partial_perc), :]
cut_gdf['truncated'] = (cut_gdf['partialDec'] != 1.0).astype(int)
else:
cut_gdf = cut_gdf[cut_gdf['geometry'].notnull()]
cut_gdf['partialDec'] = 1
cut_gdf['truncated'] = 0
if ((len(cut_gdf) > 0) and verbose):
print('clip_gdf() - gdf.iloc[0]:', gdf.iloc[0])
print('clip_gdf() - tb:', tb)
print('clip_gdf() - gdf_cut:', cut_gdf)
return cut_gdf
| 2,216,006,078,788,585,000
|
Clip GDF to a provided polygon.
Clips objects within `gdf` to the region defined by
`poly_to_cut`. Also adds several columns to the output::
`origarea`
The original area of the polygons (only used if `geom_type` ==
``"Polygon"``).
`origlen`
The original length of the objects (only used if `geom_type` ==
``"LineString"``).
`partialDec`
The fraction of the object that remains after clipping
(fraction of area for Polygons, fraction of length for
LineStrings.) Can filter based on this by using `min_partial_perc`.
`truncated`
Boolean indicator of whether or not an object was clipped.
Arguments
---------
gdf : :py:class:`geopandas.GeoDataFrame`
A :py:class:`geopandas.GeoDataFrame` of polygons to clip.
tile_bounds : `list` or :class:`shapely.geometry.Polygon`
The geometry to clip objects in `gdf` to. This can either be a
``[left, top, right, bottom] `` bounds list or a
:class:`shapely.geometry.Polygon` object defining the area to keep.
min_partial_perc : float, optional
The minimum fraction of an object in `gdf` that must be
preserved. Defaults to 0.0 (include any object if any part remains
following clipping).
geom_type : str, optional
Type of objects in `gdf`. Can be one of
``["Polygon", "LineString"]`` . Defaults to ``"Polygon"`` .
use_sindex : bool, optional
Use the `gdf` sindex be used for searching. Improves efficiency
but requires `libspatialindex <http://libspatialindex.github.io/>`__ .
verbose : bool, optional
Switch to print relevant values.
Returns
-------
cut_gdf : :py:class:`geopandas.GeoDataFrame`
`gdf` with all contained objects clipped to `poly_to_cut` .
See notes above for details on additional clipping columns added.
|
3-SatShipAI/solaris/tile/vector_tile.py
|
clip_gdf
|
CosmiQ/SpaceNet_SAR_Buildings_Solutions
|
python
|
def clip_gdf(gdf, tile_bounds, min_partial_perc=0.0, geom_type='Polygon', use_sindex=True, verbose=False):
'Clip GDF to a provided polygon.\n\n Clips objects within `gdf` to the region defined by\n `poly_to_cut`. Also adds several columns to the output::\n\n `origarea`\n The original area of the polygons (only used if `geom_type` ==\n ``"Polygon"``).\n `origlen`\n The original length of the objects (only used if `geom_type` ==\n ``"LineString"``).\n `partialDec`\n The fraction of the object that remains after clipping\n (fraction of area for Polygons, fraction of length for\n LineStrings.) Can filter based on this by using `min_partial_perc`.\n `truncated`\n Boolean indicator of whether or not an object was clipped.\n\n Arguments\n ---------\n gdf : :py:class:`geopandas.GeoDataFrame`\n A :py:class:`geopandas.GeoDataFrame` of polygons to clip.\n tile_bounds : `list` or :class:`shapely.geometry.Polygon`\n The geometry to clip objects in `gdf` to. This can either be a\n ``[left, top, right, bottom] `` bounds list or a\n :class:`shapely.geometry.Polygon` object defining the area to keep.\n min_partial_perc : float, optional\n The minimum fraction of an object in `gdf` that must be\n preserved. Defaults to 0.0 (include any object if any part remains\n following clipping).\n geom_type : str, optional\n Type of objects in `gdf`. Can be one of\n ``["Polygon", "LineString"]`` . Defaults to ``"Polygon"`` .\n use_sindex : bool, optional\n Use the `gdf` sindex be used for searching. Improves efficiency\n but requires `libspatialindex <http://libspatialindex.github.io/>`__ .\n verbose : bool, optional\n Switch to print relevant values.\n\n Returns\n -------\n cut_gdf : :py:class:`geopandas.GeoDataFrame`\n `gdf` with all contained objects clipped to `poly_to_cut` .\n See notes above for details on additional clipping columns added.\n\n '
if isinstance(tile_bounds, tuple):
tb = box(*tile_bounds)
elif isinstance(tile_bounds, list):
tb = box(*tile_bounds)
elif isinstance(tile_bounds, Polygon):
tb = tile_bounds
if (use_sindex and (geom_type == 'Polygon')):
gdf = search_gdf_polygon(gdf, tb)
if ('origarea' in gdf.columns):
pass
elif ('geom_type' == 'LineString'):
gdf['origarea'] = 0
else:
gdf['origarea'] = gdf.area
if ('origlen' in gdf.columns):
pass
elif ('geom_type' == 'LineString'):
gdf['origlen'] = gdf.length
else:
gdf['origlen'] = 0
cut_gdf = gdf.copy()
cut_gdf.geometry = gdf.intersection(tb)
if (geom_type == 'Polygon'):
cut_gdf['partialDec'] = (cut_gdf.area / cut_gdf['origarea'])
cut_gdf = cut_gdf.loc[(cut_gdf['partialDec'] > min_partial_perc), :]
cut_gdf['truncated'] = (cut_gdf['partialDec'] != 1.0).astype(int)
else:
cut_gdf = cut_gdf[cut_gdf['geometry'].notnull()]
cut_gdf['partialDec'] = 1
cut_gdf['truncated'] = 0
if ((len(cut_gdf) > 0) and verbose):
print('clip_gdf() - gdf.iloc[0]:', gdf.iloc[0])
print('clip_gdf() - tb:', tb)
print('clip_gdf() - gdf_cut:', cut_gdf)
return cut_gdf
|
def tile(self, src, tile_bounds, tile_bounds_crs=None, geom_type='Polygon', split_multi_geoms=True, min_partial_perc=0.0, dest_fname_base='geoms', obj_id_col=None, output_ext='.geojson'):
'Tile `src` into vector data tiles bounded by `tile_bounds`.\n\n Arguments\n ---------\n src : `str` or :class:`geopandas.GeoDataFrame`\n The source vector data to tile. Must either be a path to a GeoJSON\n or a :class:`geopandas.GeoDataFrame`.\n tile_bounds : list\n A :class:`list` made up of ``[left, top, right, bottom] `` sublists\n (this can be extracted from\n :class:`solaris.tile.raster_tile.RasterTiler` after tiling imagery)\n tile_bounds_crs : int, optional\n The EPSG code or rasterio.crs.CRS object for the CRS that the tile\n bounds are in. RasterTiler.tile returns the CRS of the raster tiles\n and can be used here. If not provided, it\'s assumed that the CRS is the\n same as in `src`. This argument must be provided if the bound\n coordinates and `src` are not in the same CRS, otherwise tiling will\n not occur correctly.\n geom_type : str, optional (default: "Polygon")\n The type of geometries contained within `src`. Defaults to\n ``"Polygon"``, can also be ``"LineString"``.\n split_multi_geoms : bool, optional (default: True)\n Should multi-polygons or multi-linestrings generated by clipping\n a geometry into discontinuous pieces be separated? Defaults to yes\n (``True``).\n min_partial_perc : float, optional (default: 0.0)\n The minimum percentage of a :class:`shapely.geometry.Polygon` \'s\n area or :class:`shapely.geometry.LineString` \'s length that must\n be retained within a tile\'s bounds to be included in the output.\n Defaults to ``0.0``, meaning that the contained portion of a\n clipped geometry will be included, no matter how small.\n dest_fname_base : str, optional (default: \'geoms\')\n The base filename to use when creating outputs. The lower left\n corner coordinates of the tile\'s bounding box will be appended\n when saving.\n obj_id_col : str, optional (default: None)\n If ``split_multi_geoms=True``, the name of a column that specifies\n a unique identifier for each geometry (e.g. the ``"BuildingId"``\n column in many SpaceNet datasets.) See\n :func:`solaris.utils.geo.split_multi_geometries` for more.\n output_ext : str, optional, (default: geojson)\n Extension of output files, can be \'geojson\' or \'json\'.\n '
tile_gen = self.tile_generator(src, tile_bounds, tile_bounds_crs, geom_type, split_multi_geoms, min_partial_perc, obj_id_col=obj_id_col)
self.tile_paths = []
for (tile_gdf, tb) in tqdm(tile_gen):
if (self.proj_unit not in ['meter', 'metre']):
dest_path = os.path.join(self.dest_dir, '{}_{}_{}{}'.format(dest_fname_base, np.round(tb[0], 3), np.round(tb[3], 3), output_ext))
else:
dest_path = os.path.join(self.dest_dir, '{}_{}_{}{}'.format(dest_fname_base, int(tb[0]), int(tb[3]), output_ext))
self.tile_paths.append(dest_path)
if (len(tile_gdf) > 0):
tile_gdf.to_file(dest_path, driver='GeoJSON')
else:
save_empty_geojson(dest_path, self.dest_crs)
| 2,507,140,713,211,685,400
|
Tile `src` into vector data tiles bounded by `tile_bounds`.
Arguments
---------
src : `str` or :class:`geopandas.GeoDataFrame`
The source vector data to tile. Must either be a path to a GeoJSON
or a :class:`geopandas.GeoDataFrame`.
tile_bounds : list
A :class:`list` made up of ``[left, top, right, bottom] `` sublists
(this can be extracted from
:class:`solaris.tile.raster_tile.RasterTiler` after tiling imagery)
tile_bounds_crs : int, optional
The EPSG code or rasterio.crs.CRS object for the CRS that the tile
bounds are in. RasterTiler.tile returns the CRS of the raster tiles
and can be used here. If not provided, it's assumed that the CRS is the
same as in `src`. This argument must be provided if the bound
coordinates and `src` are not in the same CRS, otherwise tiling will
not occur correctly.
geom_type : str, optional (default: "Polygon")
The type of geometries contained within `src`. Defaults to
``"Polygon"``, can also be ``"LineString"``.
split_multi_geoms : bool, optional (default: True)
Should multi-polygons or multi-linestrings generated by clipping
a geometry into discontinuous pieces be separated? Defaults to yes
(``True``).
min_partial_perc : float, optional (default: 0.0)
The minimum percentage of a :class:`shapely.geometry.Polygon` 's
area or :class:`shapely.geometry.LineString` 's length that must
be retained within a tile's bounds to be included in the output.
Defaults to ``0.0``, meaning that the contained portion of a
clipped geometry will be included, no matter how small.
dest_fname_base : str, optional (default: 'geoms')
The base filename to use when creating outputs. The lower left
corner coordinates of the tile's bounding box will be appended
when saving.
obj_id_col : str, optional (default: None)
If ``split_multi_geoms=True``, the name of a column that specifies
a unique identifier for each geometry (e.g. the ``"BuildingId"``
column in many SpaceNet datasets.) See
:func:`solaris.utils.geo.split_multi_geometries` for more.
output_ext : str, optional, (default: geojson)
Extension of output files, can be 'geojson' or 'json'.
|
3-SatShipAI/solaris/tile/vector_tile.py
|
tile
|
CosmiQ/SpaceNet_SAR_Buildings_Solutions
|
python
|
def tile(self, src, tile_bounds, tile_bounds_crs=None, geom_type='Polygon', split_multi_geoms=True, min_partial_perc=0.0, dest_fname_base='geoms', obj_id_col=None, output_ext='.geojson'):
'Tile `src` into vector data tiles bounded by `tile_bounds`.\n\n Arguments\n ---------\n src : `str` or :class:`geopandas.GeoDataFrame`\n The source vector data to tile. Must either be a path to a GeoJSON\n or a :class:`geopandas.GeoDataFrame`.\n tile_bounds : list\n A :class:`list` made up of ``[left, top, right, bottom] `` sublists\n (this can be extracted from\n :class:`solaris.tile.raster_tile.RasterTiler` after tiling imagery)\n tile_bounds_crs : int, optional\n The EPSG code or rasterio.crs.CRS object for the CRS that the tile\n bounds are in. RasterTiler.tile returns the CRS of the raster tiles\n and can be used here. If not provided, it\'s assumed that the CRS is the\n same as in `src`. This argument must be provided if the bound\n coordinates and `src` are not in the same CRS, otherwise tiling will\n not occur correctly.\n geom_type : str, optional (default: "Polygon")\n The type of geometries contained within `src`. Defaults to\n ``"Polygon"``, can also be ``"LineString"``.\n split_multi_geoms : bool, optional (default: True)\n Should multi-polygons or multi-linestrings generated by clipping\n a geometry into discontinuous pieces be separated? Defaults to yes\n (``True``).\n min_partial_perc : float, optional (default: 0.0)\n The minimum percentage of a :class:`shapely.geometry.Polygon` \'s\n area or :class:`shapely.geometry.LineString` \'s length that must\n be retained within a tile\'s bounds to be included in the output.\n Defaults to ``0.0``, meaning that the contained portion of a\n clipped geometry will be included, no matter how small.\n dest_fname_base : str, optional (default: \'geoms\')\n The base filename to use when creating outputs. The lower left\n corner coordinates of the tile\'s bounding box will be appended\n when saving.\n obj_id_col : str, optional (default: None)\n If ``split_multi_geoms=True``, the name of a column that specifies\n a unique identifier for each geometry (e.g. the ``"BuildingId"``\n column in many SpaceNet datasets.) See\n :func:`solaris.utils.geo.split_multi_geometries` for more.\n output_ext : str, optional, (default: geojson)\n Extension of output files, can be \'geojson\' or \'json\'.\n '
tile_gen = self.tile_generator(src, tile_bounds, tile_bounds_crs, geom_type, split_multi_geoms, min_partial_perc, obj_id_col=obj_id_col)
self.tile_paths = []
for (tile_gdf, tb) in tqdm(tile_gen):
if (self.proj_unit not in ['meter', 'metre']):
dest_path = os.path.join(self.dest_dir, '{}_{}_{}{}'.format(dest_fname_base, np.round(tb[0], 3), np.round(tb[3], 3), output_ext))
else:
dest_path = os.path.join(self.dest_dir, '{}_{}_{}{}'.format(dest_fname_base, int(tb[0]), int(tb[3]), output_ext))
self.tile_paths.append(dest_path)
if (len(tile_gdf) > 0):
tile_gdf.to_file(dest_path, driver='GeoJSON')
else:
save_empty_geojson(dest_path, self.dest_crs)
|
def tile_generator(self, src, tile_bounds, tile_bounds_crs=None, geom_type='Polygon', split_multi_geoms=True, min_partial_perc=0.0, obj_id_col=None):
'Generate `src` vector data tiles bounded by `tile_bounds`.\n\n Arguments\n ---------\n src : `str` or :class:`geopandas.GeoDataFrame`\n The source vector data to tile. Must either be a path to a GeoJSON\n or a :class:`geopandas.GeoDataFrame`.\n tile_bounds : list\n A :class:`list` made up of ``[left, top, right, bottom] `` sublists\n (this can be extracted from\n :class:`solaris.tile.raster_tile.RasterTiler` after tiling imagery)\n tile_bounds_crs : int, optional\n The EPSG code for the CRS that the tile bounds are in. If not\n provided, it\'s assumed that the CRS is the same as in `src`. This\n argument must be provided if the bound coordinates and `src` are\n not in the same CRS, otherwise tiling will not occur correctly.\n geom_type : str, optional (default: "Polygon")\n The type of geometries contained within `src`. Defaults to\n ``"Polygon"``, can also be ``"LineString"``.\n split_multi_geoms : bool, optional (default: True)\n Should multi-polygons or multi-linestrings generated by clipping\n a geometry into discontinuous pieces be separated? Defaults to yes\n (``True``).\n min_partial_perc : float, optional (default: 0.0)\n The minimum percentage of a :class:`shapely.geometry.Polygon` \'s\n area or :class:`shapely.geometry.LineString` \'s length that must\n be retained within a tile\'s bounds to be included in the output.\n Defaults to ``0.0``, meaning that the contained portion of a\n clipped geometry will be included, no matter how small.\n obj_id_col : str, optional (default: None)\n If ``split_multi_geoms=True``, the name of a column that specifies\n a unique identifier for each geometry (e.g. the ``"BuildingId"``\n column in many SpaceNet datasets.) See\n :func:`solaris.utils.geo.split_multi_geometries` for more.\n\n Yields\n ------\n tile_gdf : :class:`geopandas.GeoDataFrame`\n A tile geodataframe.\n tb : list\n A list with ``[left, top, right, bottom] `` coordinates for the\n boundaries contained by `tile_gdf`.\n '
self.src = _check_gdf_load(src)
if self.verbose:
print('Num tiles:', len(tile_bounds))
self.src_crs = _check_crs(self.src.crs)
if (tile_bounds_crs is not None):
tile_bounds_crs = _check_crs(tile_bounds_crs)
else:
tile_bounds_crs = self.src_crs
if (self.src_crs != tile_bounds_crs):
reproject_bounds = True
else:
reproject_bounds = False
self.proj_unit = self.src_crs.linear_units
if (getattr(self, 'dest_crs', None) is None):
self.dest_crs = self.src_crs
for (i, tb) in enumerate(tile_bounds):
if self.super_verbose:
print('\n', i, '/', len(tile_bounds))
if reproject_bounds:
tile_gdf = clip_gdf(self.src, reproject_geometry(box(*tb), tile_bounds_crs, self.src_crs), min_partial_perc, geom_type, verbose=self.super_verbose)
else:
tile_gdf = clip_gdf(self.src, tb, min_partial_perc, geom_type, verbose=self.super_verbose)
if (self.src_crs != self.dest_crs):
tile_gdf = tile_gdf.to_crs(crs=self.dest_crs.to_wkt())
if split_multi_geoms:
split_multi_geometries(tile_gdf, obj_id_col=obj_id_col)
(yield (tile_gdf, tb))
| 7,268,810,913,138,640,000
|
Generate `src` vector data tiles bounded by `tile_bounds`.
Arguments
---------
src : `str` or :class:`geopandas.GeoDataFrame`
The source vector data to tile. Must either be a path to a GeoJSON
or a :class:`geopandas.GeoDataFrame`.
tile_bounds : list
A :class:`list` made up of ``[left, top, right, bottom] `` sublists
(this can be extracted from
:class:`solaris.tile.raster_tile.RasterTiler` after tiling imagery)
tile_bounds_crs : int, optional
The EPSG code for the CRS that the tile bounds are in. If not
provided, it's assumed that the CRS is the same as in `src`. This
argument must be provided if the bound coordinates and `src` are
not in the same CRS, otherwise tiling will not occur correctly.
geom_type : str, optional (default: "Polygon")
The type of geometries contained within `src`. Defaults to
``"Polygon"``, can also be ``"LineString"``.
split_multi_geoms : bool, optional (default: True)
Should multi-polygons or multi-linestrings generated by clipping
a geometry into discontinuous pieces be separated? Defaults to yes
(``True``).
min_partial_perc : float, optional (default: 0.0)
The minimum percentage of a :class:`shapely.geometry.Polygon` 's
area or :class:`shapely.geometry.LineString` 's length that must
be retained within a tile's bounds to be included in the output.
Defaults to ``0.0``, meaning that the contained portion of a
clipped geometry will be included, no matter how small.
obj_id_col : str, optional (default: None)
If ``split_multi_geoms=True``, the name of a column that specifies
a unique identifier for each geometry (e.g. the ``"BuildingId"``
column in many SpaceNet datasets.) See
:func:`solaris.utils.geo.split_multi_geometries` for more.
Yields
------
tile_gdf : :class:`geopandas.GeoDataFrame`
A tile geodataframe.
tb : list
A list with ``[left, top, right, bottom] `` coordinates for the
boundaries contained by `tile_gdf`.
|
3-SatShipAI/solaris/tile/vector_tile.py
|
tile_generator
|
CosmiQ/SpaceNet_SAR_Buildings_Solutions
|
python
|
def tile_generator(self, src, tile_bounds, tile_bounds_crs=None, geom_type='Polygon', split_multi_geoms=True, min_partial_perc=0.0, obj_id_col=None):
'Generate `src` vector data tiles bounded by `tile_bounds`.\n\n Arguments\n ---------\n src : `str` or :class:`geopandas.GeoDataFrame`\n The source vector data to tile. Must either be a path to a GeoJSON\n or a :class:`geopandas.GeoDataFrame`.\n tile_bounds : list\n A :class:`list` made up of ``[left, top, right, bottom] `` sublists\n (this can be extracted from\n :class:`solaris.tile.raster_tile.RasterTiler` after tiling imagery)\n tile_bounds_crs : int, optional\n The EPSG code for the CRS that the tile bounds are in. If not\n provided, it\'s assumed that the CRS is the same as in `src`. This\n argument must be provided if the bound coordinates and `src` are\n not in the same CRS, otherwise tiling will not occur correctly.\n geom_type : str, optional (default: "Polygon")\n The type of geometries contained within `src`. Defaults to\n ``"Polygon"``, can also be ``"LineString"``.\n split_multi_geoms : bool, optional (default: True)\n Should multi-polygons or multi-linestrings generated by clipping\n a geometry into discontinuous pieces be separated? Defaults to yes\n (``True``).\n min_partial_perc : float, optional (default: 0.0)\n The minimum percentage of a :class:`shapely.geometry.Polygon` \'s\n area or :class:`shapely.geometry.LineString` \'s length that must\n be retained within a tile\'s bounds to be included in the output.\n Defaults to ``0.0``, meaning that the contained portion of a\n clipped geometry will be included, no matter how small.\n obj_id_col : str, optional (default: None)\n If ``split_multi_geoms=True``, the name of a column that specifies\n a unique identifier for each geometry (e.g. the ``"BuildingId"``\n column in many SpaceNet datasets.) See\n :func:`solaris.utils.geo.split_multi_geometries` for more.\n\n Yields\n ------\n tile_gdf : :class:`geopandas.GeoDataFrame`\n A tile geodataframe.\n tb : list\n A list with ``[left, top, right, bottom] `` coordinates for the\n boundaries contained by `tile_gdf`.\n '
self.src = _check_gdf_load(src)
if self.verbose:
print('Num tiles:', len(tile_bounds))
self.src_crs = _check_crs(self.src.crs)
if (tile_bounds_crs is not None):
tile_bounds_crs = _check_crs(tile_bounds_crs)
else:
tile_bounds_crs = self.src_crs
if (self.src_crs != tile_bounds_crs):
reproject_bounds = True
else:
reproject_bounds = False
self.proj_unit = self.src_crs.linear_units
if (getattr(self, 'dest_crs', None) is None):
self.dest_crs = self.src_crs
for (i, tb) in enumerate(tile_bounds):
if self.super_verbose:
print('\n', i, '/', len(tile_bounds))
if reproject_bounds:
tile_gdf = clip_gdf(self.src, reproject_geometry(box(*tb), tile_bounds_crs, self.src_crs), min_partial_perc, geom_type, verbose=self.super_verbose)
else:
tile_gdf = clip_gdf(self.src, tb, min_partial_perc, geom_type, verbose=self.super_verbose)
if (self.src_crs != self.dest_crs):
tile_gdf = tile_gdf.to_crs(crs=self.dest_crs.to_wkt())
if split_multi_geoms:
split_multi_geometries(tile_gdf, obj_id_col=obj_id_col)
(yield (tile_gdf, tb))
|
def update_allure_feature_name(results_dir: str, prefix: str):
'Make Allure JSON results unique by pre-pending a prefix to: name, historyId & uuid.\n\n Use it when not all of the test results show up in the Allure report.\n This is because tests from different workers can actually have the same: historyId & uuid values.\n\n You can use e.g. browser name as the prefix.\n '
results_dir_path = os.path.join('.', results_dir)
update_count = 0
for filename in os.listdir(results_dir_path):
if filename.endswith('.json'):
result_file = os.path.join(results_dir_path, filename)
with open(result_file, 'r') as json_file:
report = json.loads(json_file.read())
report['name'] = f"{prefix} - {report['name']}"
report['historyId'] = f"{prefix}{report['historyId']}"
report['uuid'] = f"{prefix}{report['uuid']}"
with open(result_file, 'w') as json_file:
json.dump(report, json_file, indent=2, ensure_ascii=False)
update_count += 1
print(f'Updated {update_count} JSON reports')
| -7,646,167,299,302,602,000
|
Make Allure JSON results unique by pre-pending a prefix to: name, historyId & uuid.
Use it when not all of the test results show up in the Allure report.
This is because tests from different workers can actually have the same: historyId & uuid values.
You can use e.g. browser name as the prefix.
|
update_results.py
|
update_allure_feature_name
|
tomaszwozniak/behave-docker-parallel
|
python
|
def update_allure_feature_name(results_dir: str, prefix: str):
'Make Allure JSON results unique by pre-pending a prefix to: name, historyId & uuid.\n\n Use it when not all of the test results show up in the Allure report.\n This is because tests from different workers can actually have the same: historyId & uuid values.\n\n You can use e.g. browser name as the prefix.\n '
results_dir_path = os.path.join('.', results_dir)
update_count = 0
for filename in os.listdir(results_dir_path):
if filename.endswith('.json'):
result_file = os.path.join(results_dir_path, filename)
with open(result_file, 'r') as json_file:
report = json.loads(json_file.read())
report['name'] = f"{prefix} - {report['name']}"
report['historyId'] = f"{prefix}{report['historyId']}"
report['uuid'] = f"{prefix}{report['uuid']}"
with open(result_file, 'w') as json_file:
json.dump(report, json_file, indent=2, ensure_ascii=False)
update_count += 1
print(f'Updated {update_count} JSON reports')
|
def __init__(__self__, *, factory_name: pulumi.Input[str], resource_group_name: pulumi.Input[str], private_endpoint_connection_name: Optional[pulumi.Input[str]]=None, properties: Optional[pulumi.Input['PrivateLinkConnectionApprovalRequestArgs']]=None):
"\n The set of arguments for constructing a PrivateEndpointConnection resource.\n :param pulumi.Input[str] factory_name: The factory name.\n :param pulumi.Input[str] resource_group_name: The resource group name.\n :param pulumi.Input[str] private_endpoint_connection_name: The private endpoint connection name.\n :param pulumi.Input['PrivateLinkConnectionApprovalRequestArgs'] properties: Core resource properties\n "
pulumi.set(__self__, 'factory_name', factory_name)
pulumi.set(__self__, 'resource_group_name', resource_group_name)
if (private_endpoint_connection_name is not None):
pulumi.set(__self__, 'private_endpoint_connection_name', private_endpoint_connection_name)
if (properties is not None):
pulumi.set(__self__, 'properties', properties)
| 1,770,647,843,702,379,500
|
The set of arguments for constructing a PrivateEndpointConnection resource.
:param pulumi.Input[str] factory_name: The factory name.
:param pulumi.Input[str] resource_group_name: The resource group name.
:param pulumi.Input[str] private_endpoint_connection_name: The private endpoint connection name.
:param pulumi.Input['PrivateLinkConnectionApprovalRequestArgs'] properties: Core resource properties
|
sdk/python/pulumi_azure_native/datafactory/private_endpoint_connection.py
|
__init__
|
polivbr/pulumi-azure-native
|
python
|
def __init__(__self__, *, factory_name: pulumi.Input[str], resource_group_name: pulumi.Input[str], private_endpoint_connection_name: Optional[pulumi.Input[str]]=None, properties: Optional[pulumi.Input['PrivateLinkConnectionApprovalRequestArgs']]=None):
"\n The set of arguments for constructing a PrivateEndpointConnection resource.\n :param pulumi.Input[str] factory_name: The factory name.\n :param pulumi.Input[str] resource_group_name: The resource group name.\n :param pulumi.Input[str] private_endpoint_connection_name: The private endpoint connection name.\n :param pulumi.Input['PrivateLinkConnectionApprovalRequestArgs'] properties: Core resource properties\n "
pulumi.set(__self__, 'factory_name', factory_name)
pulumi.set(__self__, 'resource_group_name', resource_group_name)
if (private_endpoint_connection_name is not None):
pulumi.set(__self__, 'private_endpoint_connection_name', private_endpoint_connection_name)
if (properties is not None):
pulumi.set(__self__, 'properties', properties)
|
@property
@pulumi.getter(name='factoryName')
def factory_name(self) -> pulumi.Input[str]:
'\n The factory name.\n '
return pulumi.get(self, 'factory_name')
| -5,996,303,779,357,339,000
|
The factory name.
|
sdk/python/pulumi_azure_native/datafactory/private_endpoint_connection.py
|
factory_name
|
polivbr/pulumi-azure-native
|
python
|
@property
@pulumi.getter(name='factoryName')
def factory_name(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'factory_name')
|
@property
@pulumi.getter(name='resourceGroupName')
def resource_group_name(self) -> pulumi.Input[str]:
'\n The resource group name.\n '
return pulumi.get(self, 'resource_group_name')
| -241,585,523,448,658,080
|
The resource group name.
|
sdk/python/pulumi_azure_native/datafactory/private_endpoint_connection.py
|
resource_group_name
|
polivbr/pulumi-azure-native
|
python
|
@property
@pulumi.getter(name='resourceGroupName')
def resource_group_name(self) -> pulumi.Input[str]:
'\n \n '
return pulumi.get(self, 'resource_group_name')
|
@property
@pulumi.getter(name='privateEndpointConnectionName')
def private_endpoint_connection_name(self) -> Optional[pulumi.Input[str]]:
'\n The private endpoint connection name.\n '
return pulumi.get(self, 'private_endpoint_connection_name')
| 5,610,363,562,574,119,000
|
The private endpoint connection name.
|
sdk/python/pulumi_azure_native/datafactory/private_endpoint_connection.py
|
private_endpoint_connection_name
|
polivbr/pulumi-azure-native
|
python
|
@property
@pulumi.getter(name='privateEndpointConnectionName')
def private_endpoint_connection_name(self) -> Optional[pulumi.Input[str]]:
'\n \n '
return pulumi.get(self, 'private_endpoint_connection_name')
|
@property
@pulumi.getter
def properties(self) -> Optional[pulumi.Input['PrivateLinkConnectionApprovalRequestArgs']]:
'\n Core resource properties\n '
return pulumi.get(self, 'properties')
| -1,592,895,317,301,340,400
|
Core resource properties
|
sdk/python/pulumi_azure_native/datafactory/private_endpoint_connection.py
|
properties
|
polivbr/pulumi-azure-native
|
python
|
@property
@pulumi.getter
def properties(self) -> Optional[pulumi.Input['PrivateLinkConnectionApprovalRequestArgs']]:
'\n \n '
return pulumi.get(self, 'properties')
|
@overload
def __init__(__self__, resource_name: str, opts: Optional[pulumi.ResourceOptions]=None, factory_name: Optional[pulumi.Input[str]]=None, private_endpoint_connection_name: Optional[pulumi.Input[str]]=None, properties: Optional[pulumi.Input[pulumi.InputType['PrivateLinkConnectionApprovalRequestArgs']]]=None, resource_group_name: Optional[pulumi.Input[str]]=None, __props__=None):
"\n Private Endpoint Connection ARM resource.\n API Version: 2018-06-01.\n\n :param str resource_name: The name of the resource.\n :param pulumi.ResourceOptions opts: Options for the resource.\n :param pulumi.Input[str] factory_name: The factory name.\n :param pulumi.Input[str] private_endpoint_connection_name: The private endpoint connection name.\n :param pulumi.Input[pulumi.InputType['PrivateLinkConnectionApprovalRequestArgs']] properties: Core resource properties\n :param pulumi.Input[str] resource_group_name: The resource group name.\n "
...
| -5,003,964,469,368,544,000
|
Private Endpoint Connection ARM resource.
API Version: 2018-06-01.
:param str resource_name: The name of the resource.
:param pulumi.ResourceOptions opts: Options for the resource.
:param pulumi.Input[str] factory_name: The factory name.
:param pulumi.Input[str] private_endpoint_connection_name: The private endpoint connection name.
:param pulumi.Input[pulumi.InputType['PrivateLinkConnectionApprovalRequestArgs']] properties: Core resource properties
:param pulumi.Input[str] resource_group_name: The resource group name.
|
sdk/python/pulumi_azure_native/datafactory/private_endpoint_connection.py
|
__init__
|
polivbr/pulumi-azure-native
|
python
|
@overload
def __init__(__self__, resource_name: str, opts: Optional[pulumi.ResourceOptions]=None, factory_name: Optional[pulumi.Input[str]]=None, private_endpoint_connection_name: Optional[pulumi.Input[str]]=None, properties: Optional[pulumi.Input[pulumi.InputType['PrivateLinkConnectionApprovalRequestArgs']]]=None, resource_group_name: Optional[pulumi.Input[str]]=None, __props__=None):
"\n Private Endpoint Connection ARM resource.\n API Version: 2018-06-01.\n\n :param str resource_name: The name of the resource.\n :param pulumi.ResourceOptions opts: Options for the resource.\n :param pulumi.Input[str] factory_name: The factory name.\n :param pulumi.Input[str] private_endpoint_connection_name: The private endpoint connection name.\n :param pulumi.Input[pulumi.InputType['PrivateLinkConnectionApprovalRequestArgs']] properties: Core resource properties\n :param pulumi.Input[str] resource_group_name: The resource group name.\n "
...
|
@overload
def __init__(__self__, resource_name: str, args: PrivateEndpointConnectionArgs, opts: Optional[pulumi.ResourceOptions]=None):
"\n Private Endpoint Connection ARM resource.\n API Version: 2018-06-01.\n\n :param str resource_name: The name of the resource.\n :param PrivateEndpointConnectionArgs args: The arguments to use to populate this resource's properties.\n :param pulumi.ResourceOptions opts: Options for the resource.\n "
...
| -2,899,717,859,708,994,000
|
Private Endpoint Connection ARM resource.
API Version: 2018-06-01.
:param str resource_name: The name of the resource.
:param PrivateEndpointConnectionArgs args: The arguments to use to populate this resource's properties.
:param pulumi.ResourceOptions opts: Options for the resource.
|
sdk/python/pulumi_azure_native/datafactory/private_endpoint_connection.py
|
__init__
|
polivbr/pulumi-azure-native
|
python
|
@overload
def __init__(__self__, resource_name: str, args: PrivateEndpointConnectionArgs, opts: Optional[pulumi.ResourceOptions]=None):
"\n Private Endpoint Connection ARM resource.\n API Version: 2018-06-01.\n\n :param str resource_name: The name of the resource.\n :param PrivateEndpointConnectionArgs args: The arguments to use to populate this resource's properties.\n :param pulumi.ResourceOptions opts: Options for the resource.\n "
...
|
@staticmethod
def get(resource_name: str, id: pulumi.Input[str], opts: Optional[pulumi.ResourceOptions]=None) -> 'PrivateEndpointConnection':
"\n Get an existing PrivateEndpointConnection resource's state with the given name, id, and optional extra\n properties used to qualify the lookup.\n\n :param str resource_name: The unique name of the resulting resource.\n :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.\n :param pulumi.ResourceOptions opts: Options for the resource.\n "
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
__props__ = PrivateEndpointConnectionArgs.__new__(PrivateEndpointConnectionArgs)
__props__.__dict__['etag'] = None
__props__.__dict__['name'] = None
__props__.__dict__['properties'] = None
__props__.__dict__['type'] = None
return PrivateEndpointConnection(resource_name, opts=opts, __props__=__props__)
| 7,485,239,997,982,850,000
|
Get an existing PrivateEndpointConnection resource's state with the given name, id, and optional extra
properties used to qualify the lookup.
:param str resource_name: The unique name of the resulting resource.
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
:param pulumi.ResourceOptions opts: Options for the resource.
|
sdk/python/pulumi_azure_native/datafactory/private_endpoint_connection.py
|
get
|
polivbr/pulumi-azure-native
|
python
|
@staticmethod
def get(resource_name: str, id: pulumi.Input[str], opts: Optional[pulumi.ResourceOptions]=None) -> 'PrivateEndpointConnection':
"\n Get an existing PrivateEndpointConnection resource's state with the given name, id, and optional extra\n properties used to qualify the lookup.\n\n :param str resource_name: The unique name of the resulting resource.\n :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.\n :param pulumi.ResourceOptions opts: Options for the resource.\n "
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
__props__ = PrivateEndpointConnectionArgs.__new__(PrivateEndpointConnectionArgs)
__props__.__dict__['etag'] = None
__props__.__dict__['name'] = None
__props__.__dict__['properties'] = None
__props__.__dict__['type'] = None
return PrivateEndpointConnection(resource_name, opts=opts, __props__=__props__)
|
@property
@pulumi.getter
def etag(self) -> pulumi.Output[str]:
'\n Etag identifies change in the resource.\n '
return pulumi.get(self, 'etag')
| 6,846,172,653,893,819,000
|
Etag identifies change in the resource.
|
sdk/python/pulumi_azure_native/datafactory/private_endpoint_connection.py
|
etag
|
polivbr/pulumi-azure-native
|
python
|
@property
@pulumi.getter
def etag(self) -> pulumi.Output[str]:
'\n \n '
return pulumi.get(self, 'etag')
|
@property
@pulumi.getter
def name(self) -> pulumi.Output[str]:
'\n The resource name.\n '
return pulumi.get(self, 'name')
| 83,947,947,173,717,940
|
The resource name.
|
sdk/python/pulumi_azure_native/datafactory/private_endpoint_connection.py
|
name
|
polivbr/pulumi-azure-native
|
python
|
@property
@pulumi.getter
def name(self) -> pulumi.Output[str]:
'\n \n '
return pulumi.get(self, 'name')
|
@property
@pulumi.getter
def properties(self) -> pulumi.Output['outputs.RemotePrivateEndpointConnectionResponse']:
'\n Core resource properties\n '
return pulumi.get(self, 'properties')
| 2,148,455,638,272,531,700
|
Core resource properties
|
sdk/python/pulumi_azure_native/datafactory/private_endpoint_connection.py
|
properties
|
polivbr/pulumi-azure-native
|
python
|
@property
@pulumi.getter
def properties(self) -> pulumi.Output['outputs.RemotePrivateEndpointConnectionResponse']:
'\n \n '
return pulumi.get(self, 'properties')
|
@property
@pulumi.getter
def type(self) -> pulumi.Output[str]:
'\n The resource type.\n '
return pulumi.get(self, 'type')
| -8,765,282,501,923,804,000
|
The resource type.
|
sdk/python/pulumi_azure_native/datafactory/private_endpoint_connection.py
|
type
|
polivbr/pulumi-azure-native
|
python
|
@property
@pulumi.getter
def type(self) -> pulumi.Output[str]:
'\n \n '
return pulumi.get(self, 'type')
|
def gridsearchCV_strategy(X_tr_data, y_tr_data, list_estimators, list_params):
"\n \n len of list_estimators and list_params should be the same. For any\n estimator you need a list of parameters to optimize. Eg\n list_estimators = [RandomForestClassifier(),\n LogisticRegression()]\n list_params = [{'n_estimators': [500,1000],\n 'max_features': [8,10],\n 'max_depth' : [4,6,8],\n 'criterion' :['gini', 'entropy']},'C': [100, 1000], 'solver' : ['lbfgs'],\n 'max_iter' : [1000, 2000], 'n_jobs' : [-1]\n }] \n "
if (len(list_estimators) != len(list_params)):
raise ValueError('list_estimators and list_params must have the same length')
class_weights = set_weights(y_tr_data)
for est in list_estimators:
est_params = est.get_params()
if ('class_weight' in est_params):
est.set_params(class_weight=class_weights)
if ('n_jobs' in est_params):
est.set_params(n_jobs=(- 1))
if ('random_state' in est_params):
est.set_params(random_state=seed)
dict_estimators_to_optimize = {}
for (estimator, parameters) in zip(list_estimators, list_params):
dict_estimators_to_optimize[estimator] = parameters
list_optimized_models = [nestedCV(estimator, X_tr_data, y_tr_data, param_grid=parameters) for (estimator, parameters) in dict_estimators_to_optimize.items()]
return list_optimized_models
| -7,745,279,451,425,029,000
|
len of list_estimators and list_params should be the same. For any
estimator you need a list of parameters to optimize. Eg
list_estimators = [RandomForestClassifier(),
LogisticRegression()]
list_params = [{'n_estimators': [500,1000],
'max_features': [8,10],
'max_depth' : [4,6,8],
'criterion' :['gini', 'entropy']},'C': [100, 1000], 'solver' : ['lbfgs'],
'max_iter' : [1000, 2000], 'n_jobs' : [-1]
}]
|
workflow_procedure_example.py
|
gridsearchCV_strategy
|
kennethriva/Machine-Learning-for-drugs-cytokines
|
python
|
def gridsearchCV_strategy(X_tr_data, y_tr_data, list_estimators, list_params):
"\n \n len of list_estimators and list_params should be the same. For any\n estimator you need a list of parameters to optimize. Eg\n list_estimators = [RandomForestClassifier(),\n LogisticRegression()]\n list_params = [{'n_estimators': [500,1000],\n 'max_features': [8,10],\n 'max_depth' : [4,6,8],\n 'criterion' :['gini', 'entropy']},'C': [100, 1000], 'solver' : ['lbfgs'],\n 'max_iter' : [1000, 2000], 'n_jobs' : [-1]\n }] \n "
if (len(list_estimators) != len(list_params)):
raise ValueError('list_estimators and list_params must have the same length')
class_weights = set_weights(y_tr_data)
for est in list_estimators:
est_params = est.get_params()
if ('class_weight' in est_params):
est.set_params(class_weight=class_weights)
if ('n_jobs' in est_params):
est.set_params(n_jobs=(- 1))
if ('random_state' in est_params):
est.set_params(random_state=seed)
dict_estimators_to_optimize = {}
for (estimator, parameters) in zip(list_estimators, list_params):
dict_estimators_to_optimize[estimator] = parameters
list_optimized_models = [nestedCV(estimator, X_tr_data, y_tr_data, param_grid=parameters) for (estimator, parameters) in dict_estimators_to_optimize.items()]
return list_optimized_models
|
@pytest.fixture(autouse=True)
def minimal_director_config(project_env_devel_environment, monkeypatch):
'set a minimal configuration for testing the director connection only'
monkeypatch.setenv('DIRECTOR_ENABLED', '1')
monkeypatch.setenv('POSTGRES_ENABLED', '0')
monkeypatch.setenv('CELERY_ENABLED', '0')
monkeypatch.setenv('REGISTRY_ENABLED', '0')
| -2,749,925,392,889,353,000
|
set a minimal configuration for testing the director connection only
|
services/director-v2/tests/unit/test_modules_director_v0.py
|
minimal_director_config
|
GitHK/osparc-simcore-forked
|
python
|
@pytest.fixture(autouse=True)
def minimal_director_config(project_env_devel_environment, monkeypatch):
monkeypatch.setenv('DIRECTOR_ENABLED', '1')
monkeypatch.setenv('POSTGRES_ENABLED', '0')
monkeypatch.setenv('CELERY_ENABLED', '0')
monkeypatch.setenv('REGISTRY_ENABLED', '0')
|
async def _send_message(client, channel: str, message: str):
'Sends a message to a channel, with basic logging & error handling.'
try:
(await client.chat_postMessage(channel=channel, text=message))
except SlackApiError as e:
logging.exception(f"error from slack API when trying to send message: {e.response['error']}")
print('Encountered SlackApiError when trying to send message (see logs.)')
except AttributeError:
logging.exception('suspected issue in Slack API when trying to send message. This bug has occured before!')
print('Encountered AttributeError when trying to send message (see logs.)')
| 3,436,122,510,676,349,000
|
Sends a message to a channel, with basic logging & error handling.
|
lsw_slackbot/slack.py
|
_send_message
|
emilyhunt/lsw-slackbot
|
python
|
async def _send_message(client, channel: str, message: str):
try:
(await client.chat_postMessage(channel=channel, text=message))
except SlackApiError as e:
logging.exception(f"error from slack API when trying to send message: {e.response['error']}")
print('Encountered SlackApiError when trying to send message (see logs.)')
except AttributeError:
logging.exception('suspected issue in Slack API when trying to send message. This bug has occured before!')
print('Encountered AttributeError when trying to send message (see logs.)')
|
async def _send_file(client, channel: str, file: Union[(Path, str)], title):
'Sends a file to a channel, with basic logging & error handling.'
if isinstance(file, Path):
file = str(file.absolute())
try:
(await client.files_upload(channels=channel, file=file, title=title))
except SlackApiError as e:
logging.exception(f"error from Slack API when trying to upload file: {e.response['error']}")
print('Encountered SlackApiError when trying to upload file (see logs.)')
except AttributeError:
logging.exception('suspected issue in Slack API when trying to upload file. This bug has occured before!')
print('Encountered AttributeError when trying to upload file (see logs.)')
| 3,063,550,516,176,200,700
|
Sends a file to a channel, with basic logging & error handling.
|
lsw_slackbot/slack.py
|
_send_file
|
emilyhunt/lsw-slackbot
|
python
|
async def _send_file(client, channel: str, file: Union[(Path, str)], title):
if isinstance(file, Path):
file = str(file.absolute())
try:
(await client.files_upload(channels=channel, file=file, title=title))
except SlackApiError as e:
logging.exception(f"error from Slack API when trying to upload file: {e.response['error']}")
print('Encountered SlackApiError when trying to upload file (see logs.)')
except AttributeError:
logging.exception('suspected issue in Slack API when trying to upload file. This bug has occured before!')
print('Encountered AttributeError when trying to upload file (see logs.)')
|
async def hello_world(client, channel: str):
'Basic function to post an init message to a channel.'
logging.info(f'Saying hello world in {channel}!')
system_name = socket.gethostname()
(await _send_message(client, channel, f'''Server time & date: {string_time()}
App is running on system {system_name}.'''))
| 8,047,278,056,876,765,000
|
Basic function to post an init message to a channel.
|
lsw_slackbot/slack.py
|
hello_world
|
emilyhunt/lsw-slackbot
|
python
|
async def hello_world(client, channel: str):
logging.info(f'Saying hello world in {channel}!')
system_name = socket.gethostname()
(await _send_message(client, channel, f'Server time & date: {string_time()}
App is running on system {system_name}.'))
|
async def send_resource_use_plot(client, channel: str, plot_kwargs: dict, title: Optional[str]=None):
'Sends a resource usage plot to a given channel.'
if (title is None):
title = f'Resource usage plot generated at {string_time()}'
else:
title = (title + f' (plot generated at {string_time()})')
logging.info('Generating a resource usage plot')
logging.debug(f'plot kwargs: {plot_kwargs}')
location_plot = (await plot_resource_use(**plot_kwargs))
logging.info(f'Sending to Slack in channel {channel}')
(await _send_file(client, channel, location_plot, title))
| 356,661,397,049,278,000
|
Sends a resource usage plot to a given channel.
|
lsw_slackbot/slack.py
|
send_resource_use_plot
|
emilyhunt/lsw-slackbot
|
python
|
async def send_resource_use_plot(client, channel: str, plot_kwargs: dict, title: Optional[str]=None):
if (title is None):
title = f'Resource usage plot generated at {string_time()}'
else:
title = (title + f' (plot generated at {string_time()})')
logging.info('Generating a resource usage plot')
logging.debug(f'plot kwargs: {plot_kwargs}')
location_plot = (await plot_resource_use(**plot_kwargs))
logging.info(f'Sending to Slack in channel {channel}')
(await _send_file(client, channel, location_plot, title))
|
async def check_memory(client, channel: str, memory_warn_fraction=0.8, sleep_time=3600):
"Quick function for checking current server memory and sending a warning to a desired channel if it's\n too high."
global _LAST_MEMORY_FRACTION
current_usage = current_memory_fraction()
if (_LAST_MEMORY_FRACTION < memory_warn_fraction):
if (current_usage > memory_warn_fraction):
(await _send_message(client, channel, f'WARNING: current memory usage at {current_usage:.2%}!'))
thread_df = (await _get_resource_usage_dataframe(measurement_time=1.0))
thread_df = thread_df.sort_values('memory')
message = ['Users with something currently running:']
for (i, a_row) in thread_df.iterrows():
message.append(f"{a_row.name}: {a_row['cpu_percent']:.2f}% CPU -- {a_row['memory']:.2f} GB-- {a_row['threads']} threads")
message.append(f'''
(no further warnings will be sent for a sleep period of {(sleep_time / (60 ** 2)):.2f} hour(s))''')
(await _send_message(client, channel, '\n'.join(message)))
(await asyncio.sleep(sleep_time))
_LAST_MEMORY_FRACTION = current_usage
| -5,734,723,959,700,612,000
|
Quick function for checking current server memory and sending a warning to a desired channel if it's
too high.
|
lsw_slackbot/slack.py
|
check_memory
|
emilyhunt/lsw-slackbot
|
python
|
async def check_memory(client, channel: str, memory_warn_fraction=0.8, sleep_time=3600):
"Quick function for checking current server memory and sending a warning to a desired channel if it's\n too high."
global _LAST_MEMORY_FRACTION
current_usage = current_memory_fraction()
if (_LAST_MEMORY_FRACTION < memory_warn_fraction):
if (current_usage > memory_warn_fraction):
(await _send_message(client, channel, f'WARNING: current memory usage at {current_usage:.2%}!'))
thread_df = (await _get_resource_usage_dataframe(measurement_time=1.0))
thread_df = thread_df.sort_values('memory')
message = ['Users with something currently running:']
for (i, a_row) in thread_df.iterrows():
message.append(f"{a_row.name}: {a_row['cpu_percent']:.2f}% CPU -- {a_row['memory']:.2f} GB-- {a_row['threads']} threads")
message.append(f'
(no further warnings will be sent for a sleep period of {(sleep_time / (60 ** 2)):.2f} hour(s))')
(await _send_message(client, channel, '\n'.join(message)))
(await asyncio.sleep(sleep_time))
_LAST_MEMORY_FRACTION = current_usage
|
@contextmanager
def run_interactive_shell_command(command, **kwargs):
'\n Runs a single command in shell and provides stdout, stderr and stdin\n streams.\n\n This function creates a context manager that sets up the process (using\n ``subprocess.Popen()``), returns to caller and waits for process to exit on\n leaving.\n\n By default the process is opened in ``universal_newlines`` mode and creates\n pipes for all streams (stdout, stderr and stdin) using ``subprocess.PIPE``\n special value. These pipes are closed automatically, so if you want to get\n the contents of the streams you should retrieve them before the context\n manager exits.\n\n >>> with run_interactive_shell_command(["echo", "TEXT"]) as p:\n ... stdout = p.stdout\n ... stdout_text = stdout.read()\n >>> stdout_text\n \'TEXT\\n\'\n >>> stdout.closed\n True\n\n Custom streams provided are not closed except of ``subprocess.PIPE``.\n\n >>> from tempfile import TemporaryFile\n >>> stream = TemporaryFile()\n >>> with run_interactive_shell_command(["echo", "TEXT"],\n ... stdout=stream) as p:\n ... stderr = p.stderr\n >>> stderr.closed\n True\n >>> stream.closed\n False\n\n :param command: The command to run on shell. This parameter can either\n be a sequence of arguments that are directly passed to\n the process or a string. A string gets splitted beforehand\n using ``shlex.split()``. If providing ``shell=True`` as a\n keyword-argument, no ``shlex.split()`` is performed and the\n command string goes directly to ``subprocess.Popen()``.\n :param kwargs: Additional keyword arguments to pass to\n ``subprocess.Popen`` that are used to spawn the process.\n :return: A context manager yielding the process started from the\n command.\n '
if ((not kwargs.get('shell', False)) and isinstance(command, str)):
command = shlex.split(command)
else:
command = list(command)
if (platform.system() == 'Windows'):
command[0] = which(command[0])
args = {'stdout': PIPE, 'stderr': PIPE, 'stdin': PIPE, 'universal_newlines': True}
args.update(kwargs)
process = Popen(command, **args)
try:
(yield process)
finally:
if (args['stdout'] is PIPE):
process.stdout.close()
if (args['stderr'] is PIPE):
process.stderr.close()
if (args['stdin'] is PIPE):
process.stdin.close()
process.wait()
| 5,621,563,442,070,463,000
|
Runs a single command in shell and provides stdout, stderr and stdin
streams.
This function creates a context manager that sets up the process (using
``subprocess.Popen()``), returns to caller and waits for process to exit on
leaving.
By default the process is opened in ``universal_newlines`` mode and creates
pipes for all streams (stdout, stderr and stdin) using ``subprocess.PIPE``
special value. These pipes are closed automatically, so if you want to get
the contents of the streams you should retrieve them before the context
manager exits.
>>> with run_interactive_shell_command(["echo", "TEXT"]) as p:
... stdout = p.stdout
... stdout_text = stdout.read()
>>> stdout_text
'TEXT\n'
>>> stdout.closed
True
Custom streams provided are not closed except of ``subprocess.PIPE``.
>>> from tempfile import TemporaryFile
>>> stream = TemporaryFile()
>>> with run_interactive_shell_command(["echo", "TEXT"],
... stdout=stream) as p:
... stderr = p.stderr
>>> stderr.closed
True
>>> stream.closed
False
:param command: The command to run on shell. This parameter can either
be a sequence of arguments that are directly passed to
the process or a string. A string gets splitted beforehand
using ``shlex.split()``. If providing ``shell=True`` as a
keyword-argument, no ``shlex.split()`` is performed and the
command string goes directly to ``subprocess.Popen()``.
:param kwargs: Additional keyword arguments to pass to
``subprocess.Popen`` that are used to spawn the process.
:return: A context manager yielding the process started from the
command.
|
venv/lib/python3.5/site-packages/coalib/misc/Shell.py
|
run_interactive_shell_command
|
prashant0598/CoffeeApp
|
python
|
@contextmanager
def run_interactive_shell_command(command, **kwargs):
'\n Runs a single command in shell and provides stdout, stderr and stdin\n streams.\n\n This function creates a context manager that sets up the process (using\n ``subprocess.Popen()``), returns to caller and waits for process to exit on\n leaving.\n\n By default the process is opened in ``universal_newlines`` mode and creates\n pipes for all streams (stdout, stderr and stdin) using ``subprocess.PIPE``\n special value. These pipes are closed automatically, so if you want to get\n the contents of the streams you should retrieve them before the context\n manager exits.\n\n >>> with run_interactive_shell_command(["echo", "TEXT"]) as p:\n ... stdout = p.stdout\n ... stdout_text = stdout.read()\n >>> stdout_text\n \'TEXT\\n\'\n >>> stdout.closed\n True\n\n Custom streams provided are not closed except of ``subprocess.PIPE``.\n\n >>> from tempfile import TemporaryFile\n >>> stream = TemporaryFile()\n >>> with run_interactive_shell_command(["echo", "TEXT"],\n ... stdout=stream) as p:\n ... stderr = p.stderr\n >>> stderr.closed\n True\n >>> stream.closed\n False\n\n :param command: The command to run on shell. This parameter can either\n be a sequence of arguments that are directly passed to\n the process or a string. A string gets splitted beforehand\n using ``shlex.split()``. If providing ``shell=True`` as a\n keyword-argument, no ``shlex.split()`` is performed and the\n command string goes directly to ``subprocess.Popen()``.\n :param kwargs: Additional keyword arguments to pass to\n ``subprocess.Popen`` that are used to spawn the process.\n :return: A context manager yielding the process started from the\n command.\n '
if ((not kwargs.get('shell', False)) and isinstance(command, str)):
command = shlex.split(command)
else:
command = list(command)
if (platform.system() == 'Windows'):
command[0] = which(command[0])
args = {'stdout': PIPE, 'stderr': PIPE, 'stdin': PIPE, 'universal_newlines': True}
args.update(kwargs)
process = Popen(command, **args)
try:
(yield process)
finally:
if (args['stdout'] is PIPE):
process.stdout.close()
if (args['stderr'] is PIPE):
process.stderr.close()
if (args['stdin'] is PIPE):
process.stdin.close()
process.wait()
|
def run_shell_command(command, stdin=None, **kwargs):
'\n Runs a single command in shell and returns the read stdout and stderr data.\n\n This function waits for the process (created using ``subprocess.Popen()``)\n to exit. Effectively it wraps ``run_interactive_shell_command()`` and uses\n ``communicate()`` on the process.\n\n See also ``run_interactive_shell_command()``.\n\n :param command: The command to run on shell. This parameter can either\n be a sequence of arguments that are directly passed to\n the process or a string. A string gets splitted beforehand\n using ``shlex.split()``.\n :param stdin: Initial input to send to the process.\n :param kwargs: Additional keyword arguments to pass to\n ``subprocess.Popen`` that is used to spawn the process.\n :return: A tuple with ``(stdoutstring, stderrstring)``.\n '
with run_interactive_shell_command(command, **kwargs) as p:
ret = p.communicate(stdin)
return ShellCommandResult(p.returncode, *ret)
| -630,692,324,390,031,900
|
Runs a single command in shell and returns the read stdout and stderr data.
This function waits for the process (created using ``subprocess.Popen()``)
to exit. Effectively it wraps ``run_interactive_shell_command()`` and uses
``communicate()`` on the process.
See also ``run_interactive_shell_command()``.
:param command: The command to run on shell. This parameter can either
be a sequence of arguments that are directly passed to
the process or a string. A string gets splitted beforehand
using ``shlex.split()``.
:param stdin: Initial input to send to the process.
:param kwargs: Additional keyword arguments to pass to
``subprocess.Popen`` that is used to spawn the process.
:return: A tuple with ``(stdoutstring, stderrstring)``.
|
venv/lib/python3.5/site-packages/coalib/misc/Shell.py
|
run_shell_command
|
prashant0598/CoffeeApp
|
python
|
def run_shell_command(command, stdin=None, **kwargs):
'\n Runs a single command in shell and returns the read stdout and stderr data.\n\n This function waits for the process (created using ``subprocess.Popen()``)\n to exit. Effectively it wraps ``run_interactive_shell_command()`` and uses\n ``communicate()`` on the process.\n\n See also ``run_interactive_shell_command()``.\n\n :param command: The command to run on shell. This parameter can either\n be a sequence of arguments that are directly passed to\n the process or a string. A string gets splitted beforehand\n using ``shlex.split()``.\n :param stdin: Initial input to send to the process.\n :param kwargs: Additional keyword arguments to pass to\n ``subprocess.Popen`` that is used to spawn the process.\n :return: A tuple with ``(stdoutstring, stderrstring)``.\n '
with run_interactive_shell_command(command, **kwargs) as p:
ret = p.communicate(stdin)
return ShellCommandResult(p.returncode, *ret)
|
def get_shell_type():
'\n Finds the current shell type based on the outputs of common pre-defined\n variables in them. This is useful to identify which sort of escaping\n is required for strings.\n\n :return: The shell type. This can be either "powershell" if Windows\n Powershell is detected, "cmd" if command prompt is been\n detected or "sh" if it\'s neither of these.\n '
out = run_shell_command('echo $host.name', shell=True)[0]
if (out.strip() == 'ConsoleHost'):
return 'powershell'
out = run_shell_command('echo $0', shell=True)[0]
if (out.strip() == '$0'):
return 'cmd'
return 'sh'
| -1,616,651,017,276,184,600
|
Finds the current shell type based on the outputs of common pre-defined
variables in them. This is useful to identify which sort of escaping
is required for strings.
:return: The shell type. This can be either "powershell" if Windows
Powershell is detected, "cmd" if command prompt is been
detected or "sh" if it's neither of these.
|
venv/lib/python3.5/site-packages/coalib/misc/Shell.py
|
get_shell_type
|
prashant0598/CoffeeApp
|
python
|
def get_shell_type():
'\n Finds the current shell type based on the outputs of common pre-defined\n variables in them. This is useful to identify which sort of escaping\n is required for strings.\n\n :return: The shell type. This can be either "powershell" if Windows\n Powershell is detected, "cmd" if command prompt is been\n detected or "sh" if it\'s neither of these.\n '
out = run_shell_command('echo $host.name', shell=True)[0]
if (out.strip() == 'ConsoleHost'):
return 'powershell'
out = run_shell_command('echo $0', shell=True)[0]
if (out.strip() == '$0'):
return 'cmd'
return 'sh'
|
def __new__(cls, code, stdout, stderr):
'\n Creates the basic tuple from `stdout` and `stderr`.\n '
return tuple.__new__(cls, (stdout, stderr))
| 7,544,805,995,592,937,000
|
Creates the basic tuple from `stdout` and `stderr`.
|
venv/lib/python3.5/site-packages/coalib/misc/Shell.py
|
__new__
|
prashant0598/CoffeeApp
|
python
|
def __new__(cls, code, stdout, stderr):
'\n \n '
return tuple.__new__(cls, (stdout, stderr))
|
def __init__(self, code, stdout, stderr):
'\n Stores the return `code`.\n '
self.code = code
| 1,569,877,413,911,321,300
|
Stores the return `code`.
|
venv/lib/python3.5/site-packages/coalib/misc/Shell.py
|
__init__
|
prashant0598/CoffeeApp
|
python
|
def __init__(self, code, stdout, stderr):
'\n \n '
self.code = code
|
def initialize_hyper_parameters(layer_acts, learning_rate):
'\n Initialize parameters for different levels of the network\n\n Arguments:\n layer_acts -- python array (list) containing the activation functions of each layer in the network\n learning_rate -- float value used as constant for gradient descent\n\n Returns:\n hyper_parameters -- python dictionary containing hyper_parameters (can be further extended)\n\n '
hyper_parameters = {}
activations = {}
L = len(layer_acts)
for l in range(0, L):
activations[(l + 1)] = layer_acts[l]
hyper_parameters['activations'] = activations
hyper_parameters['learning_rate'] = learning_rate
return hyper_parameters
| -2,719,787,199,406,470,700
|
Initialize parameters for different levels of the network
Arguments:
layer_acts -- python array (list) containing the activation functions of each layer in the network
learning_rate -- float value used as constant for gradient descent
Returns:
hyper_parameters -- python dictionary containing hyper_parameters (can be further extended)
|
utils/init_parameters.py
|
initialize_hyper_parameters
|
giuseppefutia/word2vec
|
python
|
def initialize_hyper_parameters(layer_acts, learning_rate):
'\n Initialize parameters for different levels of the network\n\n Arguments:\n layer_acts -- python array (list) containing the activation functions of each layer in the network\n learning_rate -- float value used as constant for gradient descent\n\n Returns:\n hyper_parameters -- python dictionary containing hyper_parameters (can be further extended)\n\n '
hyper_parameters = {}
activations = {}
L = len(layer_acts)
for l in range(0, L):
activations[(l + 1)] = layer_acts[l]
hyper_parameters['activations'] = activations
hyper_parameters['learning_rate'] = learning_rate
return hyper_parameters
|
def initialize_parameters(layer_dims):
'\n Initialize parameters for different levels of the network\n\n Arguments:\n layer_dims -- python array (list) containing the dimensions of each layer in the network\n\n Returns:\n parameters -- python dictionary containing your parameters "W1", "b1", ..., "WL", "bL", ...:\n Wl -- weight matrix of shape (layer_dims[l], layer_dims[l-1])\n bl -- bias vector of shape (layer_dims[l], 1)\n '
np.random.seed(1)
parameters = {}
L = len(layer_dims)
for l in range(1, L):
parameters[('W' + str(l))] = (np.random.randn(layer_dims[l], layer_dims[(l - 1)]) * 0.01)
parameters[('b' + str(l))] = np.zeros((layer_dims[l], 1))
assert (parameters[('W' + str(l))].shape == (layer_dims[l], layer_dims[(l - 1)]))
assert (parameters[('b' + str(l))].shape == (layer_dims[l], 1))
return parameters
| 5,596,424,596,830,611,000
|
Initialize parameters for different levels of the network
Arguments:
layer_dims -- python array (list) containing the dimensions of each layer in the network
Returns:
parameters -- python dictionary containing your parameters "W1", "b1", ..., "WL", "bL", ...:
Wl -- weight matrix of shape (layer_dims[l], layer_dims[l-1])
bl -- bias vector of shape (layer_dims[l], 1)
|
utils/init_parameters.py
|
initialize_parameters
|
giuseppefutia/word2vec
|
python
|
def initialize_parameters(layer_dims):
'\n Initialize parameters for different levels of the network\n\n Arguments:\n layer_dims -- python array (list) containing the dimensions of each layer in the network\n\n Returns:\n parameters -- python dictionary containing your parameters "W1", "b1", ..., "WL", "bL", ...:\n Wl -- weight matrix of shape (layer_dims[l], layer_dims[l-1])\n bl -- bias vector of shape (layer_dims[l], 1)\n '
np.random.seed(1)
parameters = {}
L = len(layer_dims)
for l in range(1, L):
parameters[('W' + str(l))] = (np.random.randn(layer_dims[l], layer_dims[(l - 1)]) * 0.01)
parameters[('b' + str(l))] = np.zeros((layer_dims[l], 1))
assert (parameters[('W' + str(l))].shape == (layer_dims[l], layer_dims[(l - 1)]))
assert (parameters[('b' + str(l))].shape == (layer_dims[l], 1))
return parameters
|
def _test_cache_clear(self, refresh_each_time=True):
"\n A test to make sure that the cache clearing is working as expected.\n This test gets run twice using different values for refresh_each_time.\n This makes sure that the mechanism used for clearing the cache works\n whether you're updating a document you just saved or getting a document\n fresh from the database and updating it.\n "
created = PhoneNumber(domain='phone-number-test', owner_doc_type='CommCareCase', owner_id='fake-owner-id1', phone_number='99912341234', backend_id=None, ivr_backend_id=None, verified=True, pending_verification=False, is_two_way=True, contact_last_modified=datetime.utcnow())
created.save()
self.assertNoMatch('99952345234', '52345234', 'fake-owner-id2')
self.assertMatch(created, '99912341234', '12341234', 'fake-owner-id1')
if refresh_each_time:
created = PhoneNumber.objects.get(pk=created.pk)
created.phone_number = '99952345234'
created.save()
self.assertNoMatch('99912341234', '12341234', 'fake-owner-id2')
self.assertMatch(created, '99952345234', '52345234', 'fake-owner-id1')
if refresh_each_time:
created = PhoneNumber.objects.get(pk=created.pk)
created.owner_id = 'fake-owner-id2'
created.save()
self.assertNoMatch('99912341234', '12341234', 'fake-owner-id1')
self.assertMatch(created, '99952345234', '52345234', 'fake-owner-id2')
created.delete()
self.assertNoMatch('99952345234', '52345234', 'fake-owner-id2')
| 4,466,586,823,606,075,000
|
A test to make sure that the cache clearing is working as expected.
This test gets run twice using different values for refresh_each_time.
This makes sure that the mechanism used for clearing the cache works
whether you're updating a document you just saved or getting a document
fresh from the database and updating it.
|
corehq/apps/sms/tests/test_phone_numbers.py
|
_test_cache_clear
|
AliRizvi1/commcare-hq
|
python
|
def _test_cache_clear(self, refresh_each_time=True):
"\n A test to make sure that the cache clearing is working as expected.\n This test gets run twice using different values for refresh_each_time.\n This makes sure that the mechanism used for clearing the cache works\n whether you're updating a document you just saved or getting a document\n fresh from the database and updating it.\n "
created = PhoneNumber(domain='phone-number-test', owner_doc_type='CommCareCase', owner_id='fake-owner-id1', phone_number='99912341234', backend_id=None, ivr_backend_id=None, verified=True, pending_verification=False, is_two_way=True, contact_last_modified=datetime.utcnow())
created.save()
self.assertNoMatch('99952345234', '52345234', 'fake-owner-id2')
self.assertMatch(created, '99912341234', '12341234', 'fake-owner-id1')
if refresh_each_time:
created = PhoneNumber.objects.get(pk=created.pk)
created.phone_number = '99952345234'
created.save()
self.assertNoMatch('99912341234', '12341234', 'fake-owner-id2')
self.assertMatch(created, '99952345234', '52345234', 'fake-owner-id1')
if refresh_each_time:
created = PhoneNumber.objects.get(pk=created.pk)
created.owner_id = 'fake-owner-id2'
created.save()
self.assertNoMatch('99912341234', '12341234', 'fake-owner-id1')
self.assertMatch(created, '99952345234', '52345234', 'fake-owner-id2')
created.delete()
self.assertNoMatch('99952345234', '52345234', 'fake-owner-id2')
|
def _is_available(self, j):
'Return True if the index j is available in the table.'
return ((self._table[j] is None) or (self._table[j] is ProbeHashMap._AVAIL))
| -5,279,458,529,970,227,000
|
Return True if the index j is available in the table.
|
CHAPTER 10 (maps, hash tables and skip lists)/probe_hash_map_class.py
|
_is_available
|
ahammadshawki8/DSA-Implementations-in-Python
|
python
|
def _is_available(self, j):
return ((self._table[j] is None) or (self._table[j] is ProbeHashMap._AVAIL))
|
def _find_slot(self, j, k):
'Search for key k in bucket at index j.\n\n Return (success, index) tuple, described as follows:\n If match was found, success is True and index denotes its location.\n If no match found, success is False and index denotes first available slot.\n '
firstAvail = None
while True:
if self._is_available(j):
if (firstAvail is None):
firstAvail = j
if (self._table[j] is None):
return (False, firstAvail)
elif (k == self._table[j]._key):
return (True, j)
j = ((j + 1) % len(self._table))
| -3,544,964,413,999,697,000
|
Search for key k in bucket at index j.
Return (success, index) tuple, described as follows:
If match was found, success is True and index denotes its location.
If no match found, success is False and index denotes first available slot.
|
CHAPTER 10 (maps, hash tables and skip lists)/probe_hash_map_class.py
|
_find_slot
|
ahammadshawki8/DSA-Implementations-in-Python
|
python
|
def _find_slot(self, j, k):
'Search for key k in bucket at index j.\n\n Return (success, index) tuple, described as follows:\n If match was found, success is True and index denotes its location.\n If no match found, success is False and index denotes first available slot.\n '
firstAvail = None
while True:
if self._is_available(j):
if (firstAvail is None):
firstAvail = j
if (self._table[j] is None):
return (False, firstAvail)
elif (k == self._table[j]._key):
return (True, j)
j = ((j + 1) % len(self._table))
|
def set_module_args(args):
'prepare arguments so that they will be picked up during module creation'
args = json.dumps({'ANSIBLE_MODULE_ARGS': args})
basic._ANSIBLE_ARGS = to_bytes(args)
| 1,060,042,919,257,690,400
|
prepare arguments so that they will be picked up during module creation
|
venv/lib/python3.6/site-packages/ansible_collections/netapp/ontap/tests/unit/plugins/modules/test_na_ontap_rest_cli.py
|
set_module_args
|
elixir-no-nels/usegalaxy
|
python
|
def set_module_args(args):
args = json.dumps({'ANSIBLE_MODULE_ARGS': args})
basic._ANSIBLE_ARGS = to_bytes(args)
|
def exit_json(*args, **kwargs):
'function to patch over exit_json; package return data into an exception'
if ('changed' not in kwargs):
kwargs['changed'] = False
raise AnsibleExitJson(kwargs)
| 3,969,839,544,963,715,000
|
function to patch over exit_json; package return data into an exception
|
venv/lib/python3.6/site-packages/ansible_collections/netapp/ontap/tests/unit/plugins/modules/test_na_ontap_rest_cli.py
|
exit_json
|
elixir-no-nels/usegalaxy
|
python
|
def exit_json(*args, **kwargs):
if ('changed' not in kwargs):
kwargs['changed'] = False
raise AnsibleExitJson(kwargs)
|
def fail_json(*args, **kwargs):
'function to patch over fail_json; package return data into an exception'
kwargs['failed'] = True
raise AnsibleFailJson(kwargs)
| -2,763,931,371,331,730,400
|
function to patch over fail_json; package return data into an exception
|
venv/lib/python3.6/site-packages/ansible_collections/netapp/ontap/tests/unit/plugins/modules/test_na_ontap_rest_cli.py
|
fail_json
|
elixir-no-nels/usegalaxy
|
python
|
def fail_json(*args, **kwargs):
kwargs['failed'] = True
raise AnsibleFailJson(kwargs)
|
def test_module_fail_when_required_args_missing(self):
' required arguments are reported as errors '
with pytest.raises(AnsibleFailJson) as exc:
set_module_args({})
rest_cli_module()
print(('Info: %s' % exc.value.args[0]['msg']))
| 3,425,096,439,026,092,500
|
required arguments are reported as errors
|
venv/lib/python3.6/site-packages/ansible_collections/netapp/ontap/tests/unit/plugins/modules/test_na_ontap_rest_cli.py
|
test_module_fail_when_required_args_missing
|
elixir-no-nels/usegalaxy
|
python
|
def test_module_fail_when_required_args_missing(self):
' '
with pytest.raises(AnsibleFailJson) as exc:
set_module_args({})
rest_cli_module()
print(('Info: %s' % exc.value.args[0]['msg']))
|
def _as_graph_element(obj):
'Retrieves Graph element.'
graph = ops.get_default_graph()
if (not isinstance(obj, six.string_types)):
if ((not hasattr(obj, 'graph')) or (obj.graph != graph)):
raise ValueError(('Passed %s should have graph attribute that is equal to current graph %s.' % (obj, graph)))
return obj
if (':' in obj):
element = graph.as_graph_element(obj)
else:
element = graph.as_graph_element((obj + ':0'))
try:
graph.as_graph_element((obj + ':1'))
except (KeyError, ValueError):
pass
else:
raise ValueError(('Name %s is ambiguous, as this `Operation` has multiple outputs (at least 2).' % obj))
return element
| -4,531,516,043,276,649,000
|
Retrieves Graph element.
|
tensorflow/contrib/learn/python/learn/basic_session_run_hooks.py
|
_as_graph_element
|
Najah-lshanableh/tensorflow
|
python
|
def _as_graph_element(obj):
graph = ops.get_default_graph()
if (not isinstance(obj, six.string_types)):
if ((not hasattr(obj, 'graph')) or (obj.graph != graph)):
raise ValueError(('Passed %s should have graph attribute that is equal to current graph %s.' % (obj, graph)))
return obj
if (':' in obj):
element = graph.as_graph_element(obj)
else:
element = graph.as_graph_element((obj + ':0'))
try:
graph.as_graph_element((obj + ':1'))
except (KeyError, ValueError):
pass
else:
raise ValueError(('Name %s is ambiguous, as this `Operation` has multiple outputs (at least 2).' % obj))
return element
|
def __init__(self, tensors, every_n_iter=100):
'Initializes a LoggingHook monitor.\n\n Args:\n tensors: `dict` of tag to tensors/names or\n `iterable` of tensors/names.\n every_n_iter: `int`, print every N iteration.\n\n Raises:\n ValueError: if `every_n_iter` is non-positive.\n '
if (every_n_iter <= 0):
raise ValueError(('Invalid every_n_iter=%s.' % every_n_iter))
if (not isinstance(tensors, dict)):
tensors = {item: item for item in tensors}
self._tensors = tensors
self._every_n_iter = every_n_iter
| 5,319,640,423,092,017,000
|
Initializes a LoggingHook monitor.
Args:
tensors: `dict` of tag to tensors/names or
`iterable` of tensors/names.
every_n_iter: `int`, print every N iteration.
Raises:
ValueError: if `every_n_iter` is non-positive.
|
tensorflow/contrib/learn/python/learn/basic_session_run_hooks.py
|
__init__
|
Najah-lshanableh/tensorflow
|
python
|
def __init__(self, tensors, every_n_iter=100):
'Initializes a LoggingHook monitor.\n\n Args:\n tensors: `dict` of tag to tensors/names or\n `iterable` of tensors/names.\n every_n_iter: `int`, print every N iteration.\n\n Raises:\n ValueError: if `every_n_iter` is non-positive.\n '
if (every_n_iter <= 0):
raise ValueError(('Invalid every_n_iter=%s.' % every_n_iter))
if (not isinstance(tensors, dict)):
tensors = {item: item for item in tensors}
self._tensors = tensors
self._every_n_iter = every_n_iter
|
def __init__(self, num_steps=None, last_step=None):
'Create a StopAtStep Hook.\n\n This hook requests stop after either a number of steps have been\n executed or a last step has been reached. Only of the two options can be\n specified.\n\n if `num_steps` is specified, it indicates the number of steps to execute\n after `begin()` is called. If instead `last_step` is specified, it\n indicates the last step we want to execute, as passed to the `after_run()`\n call.\n\n Args:\n num_steps: Number of steps to execute.\n last_step: Step after which to stop.\n\n Raises:\n ValueError: If one of the arguments is invalid.\n '
if ((num_steps is None) and (last_step is None)):
raise ValueError('One of num_steps or last_step must be specified.')
if ((num_steps is not None) and (last_step is not None)):
raise ValueError('Only one of num_steps or last_step can be specified.')
self._num_steps = num_steps
self._last_step = last_step
| -3,270,074,497,911,886,300
|
Create a StopAtStep Hook.
This hook requests stop after either a number of steps have been
executed or a last step has been reached. Only of the two options can be
specified.
if `num_steps` is specified, it indicates the number of steps to execute
after `begin()` is called. If instead `last_step` is specified, it
indicates the last step we want to execute, as passed to the `after_run()`
call.
Args:
num_steps: Number of steps to execute.
last_step: Step after which to stop.
Raises:
ValueError: If one of the arguments is invalid.
|
tensorflow/contrib/learn/python/learn/basic_session_run_hooks.py
|
__init__
|
Najah-lshanableh/tensorflow
|
python
|
def __init__(self, num_steps=None, last_step=None):
'Create a StopAtStep Hook.\n\n This hook requests stop after either a number of steps have been\n executed or a last step has been reached. Only of the two options can be\n specified.\n\n if `num_steps` is specified, it indicates the number of steps to execute\n after `begin()` is called. If instead `last_step` is specified, it\n indicates the last step we want to execute, as passed to the `after_run()`\n call.\n\n Args:\n num_steps: Number of steps to execute.\n last_step: Step after which to stop.\n\n Raises:\n ValueError: If one of the arguments is invalid.\n '
if ((num_steps is None) and (last_step is None)):
raise ValueError('One of num_steps or last_step must be specified.')
if ((num_steps is not None) and (last_step is not None)):
raise ValueError('Only one of num_steps or last_step can be specified.')
self._num_steps = num_steps
self._last_step = last_step
|
def __init__(self, checkpoint_dir, save_secs=None, save_steps=None, saver=None, checkpoint_basename='model.ckpt', scaffold=None):
'Initialize CheckpointSaverHook monitor.\n\n Args:\n checkpoint_dir: `str`, base directory for the checkpoint files.\n save_secs: `int`, save every N secs.\n save_steps: `int`, save every N steps.\n saver: `Saver` object, used for saving.\n checkpoint_basename: `str`, base name for the checkpoint files.\n scaffold: `Scaffold`, use to get saver object.\n\n Raises:\n ValueError: One of `save_steps` or `save_secs` should be set.\n '
logging.info('Create CheckpointSaverHook.')
self._saver = saver
self._checkpoint_dir = checkpoint_dir
self._summary_writer = SummaryWriterCache.get(checkpoint_dir)
self._save_path = os.path.join(checkpoint_dir, checkpoint_basename)
self._scaffold = scaffold
self._save_secs = save_secs
self._save_steps = save_steps
self._last_saved_time = None
self._last_saved_step = None
if ((save_steps is None) and (save_secs is None)):
raise ValueError('Either save_steps or save_secs should be provided')
if ((save_steps is not None) and (save_secs is not None)):
raise ValueError('Can not provide both save_steps and save_secs.')
| -2,173,653,760,690,871,600
|
Initialize CheckpointSaverHook monitor.
Args:
checkpoint_dir: `str`, base directory for the checkpoint files.
save_secs: `int`, save every N secs.
save_steps: `int`, save every N steps.
saver: `Saver` object, used for saving.
checkpoint_basename: `str`, base name for the checkpoint files.
scaffold: `Scaffold`, use to get saver object.
Raises:
ValueError: One of `save_steps` or `save_secs` should be set.
|
tensorflow/contrib/learn/python/learn/basic_session_run_hooks.py
|
__init__
|
Najah-lshanableh/tensorflow
|
python
|
def __init__(self, checkpoint_dir, save_secs=None, save_steps=None, saver=None, checkpoint_basename='model.ckpt', scaffold=None):
'Initialize CheckpointSaverHook monitor.\n\n Args:\n checkpoint_dir: `str`, base directory for the checkpoint files.\n save_secs: `int`, save every N secs.\n save_steps: `int`, save every N steps.\n saver: `Saver` object, used for saving.\n checkpoint_basename: `str`, base name for the checkpoint files.\n scaffold: `Scaffold`, use to get saver object.\n\n Raises:\n ValueError: One of `save_steps` or `save_secs` should be set.\n '
logging.info('Create CheckpointSaverHook.')
self._saver = saver
self._checkpoint_dir = checkpoint_dir
self._summary_writer = SummaryWriterCache.get(checkpoint_dir)
self._save_path = os.path.join(checkpoint_dir, checkpoint_basename)
self._scaffold = scaffold
self._save_secs = save_secs
self._save_steps = save_steps
self._last_saved_time = None
self._last_saved_step = None
if ((save_steps is None) and (save_secs is None)):
raise ValueError('Either save_steps or save_secs should be provided')
if ((save_steps is not None) and (save_secs is not None)):
raise ValueError('Can not provide both save_steps and save_secs.')
|
def _save(self, step, session):
'Saves the latest checkpoint.'
if (step == self._last_saved_step):
return
logging.info('Saving checkpoints for %d into %s.', step, self._save_path)
self._last_saved_time = time.time()
self._last_saved_step = step
if (self._saver is None):
self._scaffold.saver.save(session, self._save_path, global_step=step)
else:
self._saver.save(session, self._save_path, global_step=step)
self._summary_writer.add_session_log(SessionLog(status=SessionLog.CHECKPOINT, checkpoint_path=self._save_path), step)
| 9,139,546,512,531,420,000
|
Saves the latest checkpoint.
|
tensorflow/contrib/learn/python/learn/basic_session_run_hooks.py
|
_save
|
Najah-lshanableh/tensorflow
|
python
|
def _save(self, step, session):
if (step == self._last_saved_step):
return
logging.info('Saving checkpoints for %d into %s.', step, self._save_path)
self._last_saved_time = time.time()
self._last_saved_step = step
if (self._saver is None):
self._scaffold.saver.save(session, self._save_path, global_step=step)
else:
self._saver.save(session, self._save_path, global_step=step)
self._summary_writer.add_session_log(SessionLog(status=SessionLog.CHECKPOINT, checkpoint_path=self._save_path), step)
|
def __init__(self, loss_tensor, fail_on_nan_loss=True):
'Initializes NanLoss monitor.\n\n Args:\n loss_tensor: `Tensor`, the loss tensor.\n fail_on_nan_loss: `bool`, whether to raise exception when loss is NaN.\n '
self._loss_tensor = loss_tensor
self._fail_on_nan_loss = fail_on_nan_loss
| 3,097,157,734,419,355,000
|
Initializes NanLoss monitor.
Args:
loss_tensor: `Tensor`, the loss tensor.
fail_on_nan_loss: `bool`, whether to raise exception when loss is NaN.
|
tensorflow/contrib/learn/python/learn/basic_session_run_hooks.py
|
__init__
|
Najah-lshanableh/tensorflow
|
python
|
def __init__(self, loss_tensor, fail_on_nan_loss=True):
'Initializes NanLoss monitor.\n\n Args:\n loss_tensor: `Tensor`, the loss tensor.\n fail_on_nan_loss: `bool`, whether to raise exception when loss is NaN.\n '
self._loss_tensor = loss_tensor
self._fail_on_nan_loss = fail_on_nan_loss
|
def __init__(self, save_steps=100, output_dir=None, summary_writer=None, scaffold=None, summary_op=None):
"Initializes a `SummarySaver` monitor.\n\n Args:\n save_steps: `int`, save summaries every N steps. See `EveryN`.\n output_dir: `string`, the directory to save the summaries to. Only used\n if no `summary_writer` is supplied.\n summary_writer: `SummaryWriter`. If `None` and an `output_dir` was passed,\n one will be created accordingly.\n scaffold: `Scaffold` to get summary_op if it's not provided.\n summary_op: `Tensor` of type `string`. A serialized `Summary` protocol\n buffer, as output by TF summary methods like `scalar_summary` or\n `merge_all_summaries`.\n "
self._summary_op = summary_op
self._summary_writer = summary_writer
if ((summary_writer is None) and output_dir):
self._summary_writer = SummaryWriterCache.get(output_dir)
self._scaffold = scaffold
self._save_steps = save_steps
| 354,916,776,997,065,860
|
Initializes a `SummarySaver` monitor.
Args:
save_steps: `int`, save summaries every N steps. See `EveryN`.
output_dir: `string`, the directory to save the summaries to. Only used
if no `summary_writer` is supplied.
summary_writer: `SummaryWriter`. If `None` and an `output_dir` was passed,
one will be created accordingly.
scaffold: `Scaffold` to get summary_op if it's not provided.
summary_op: `Tensor` of type `string`. A serialized `Summary` protocol
buffer, as output by TF summary methods like `scalar_summary` or
`merge_all_summaries`.
|
tensorflow/contrib/learn/python/learn/basic_session_run_hooks.py
|
__init__
|
Najah-lshanableh/tensorflow
|
python
|
def __init__(self, save_steps=100, output_dir=None, summary_writer=None, scaffold=None, summary_op=None):
"Initializes a `SummarySaver` monitor.\n\n Args:\n save_steps: `int`, save summaries every N steps. See `EveryN`.\n output_dir: `string`, the directory to save the summaries to. Only used\n if no `summary_writer` is supplied.\n summary_writer: `SummaryWriter`. If `None` and an `output_dir` was passed,\n one will be created accordingly.\n scaffold: `Scaffold` to get summary_op if it's not provided.\n summary_op: `Tensor` of type `string`. A serialized `Summary` protocol\n buffer, as output by TF summary methods like `scalar_summary` or\n `merge_all_summaries`.\n "
self._summary_op = summary_op
self._summary_writer = summary_writer
if ((summary_writer is None) and output_dir):
self._summary_writer = SummaryWriterCache.get(output_dir)
self._scaffold = scaffold
self._save_steps = save_steps
|
def __eq__(self, *args):
' x.__eq__(y) <==> x==yx.__eq__(y) <==> x==yx.__eq__(y) <==> x==y '
pass
| 2,144,965,521,805,394,200
|
x.__eq__(y) <==> x==yx.__eq__(y) <==> x==yx.__eq__(y) <==> x==y
|
stubs.min/Autodesk/Revit/DB/__init___parts/RenderNodeAction.py
|
__eq__
|
denfromufa/ironpython-stubs
|
python
|
def __eq__(self, *args):
' '
pass
|
def __format__(self, *args):
' __format__(formattable: IFormattable,format: str) -> str '
pass
| -4,894,195,495,142,889,000
|
__format__(formattable: IFormattable,format: str) -> str
|
stubs.min/Autodesk/Revit/DB/__init___parts/RenderNodeAction.py
|
__format__
|
denfromufa/ironpython-stubs
|
python
|
def __format__(self, *args):
' '
pass
|
def __init__(self, *args):
' x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature '
pass
| -90,002,593,062,007,400
|
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature
|
stubs.min/Autodesk/Revit/DB/__init___parts/RenderNodeAction.py
|
__init__
|
denfromufa/ironpython-stubs
|
python
|
def __init__(self, *args):
' '
pass
|
def _from_json(json_str):
'Turns json -> object (or None if json cannot be parsed).'
try:
return transforms.loads(json_str)
except:
return None
| 4,839,327,838,972,727,000
|
Turns json -> object (or None if json cannot be parsed).
|
modules/balancer/balancer.py
|
_from_json
|
ehiller/CourseBuilderV19-TeacherDashboard
|
python
|
def _from_json(json_str):
try:
return transforms.loads(json_str)
except:
return None
|
@classmethod
def create(cls, user_id=None):
'Creates task and returns ticket string.'
task = _ExternalTask(status=_ExternalTask.CREATED, user_id=user_id)
return _ExternalTask.get_ticket_by_key(db.put(task))
| 1,251,493,781,329,727,200
|
Creates task and returns ticket string.
|
modules/balancer/balancer.py
|
create
|
ehiller/CourseBuilderV19-TeacherDashboard
|
python
|
@classmethod
def create(cls, user_id=None):
task = _ExternalTask(status=_ExternalTask.CREATED, user_id=user_id)
return _ExternalTask.get_ticket_by_key(db.put(task))
|
@classmethod
def get(cls, ticket):
'Gets task for ticket (or None if no matching task).'
external_task = db.get(_ExternalTask.get_key_by_ticket(ticket))
if (not external_task):
return None
return Task._from_external_task(external_task)
| 4,956,127,845,216,087,000
|
Gets task for ticket (or None if no matching task).
|
modules/balancer/balancer.py
|
get
|
ehiller/CourseBuilderV19-TeacherDashboard
|
python
|
@classmethod
def get(cls, ticket):
external_task = db.get(_ExternalTask.get_key_by_ticket(ticket))
if (not external_task):
return None
return Task._from_external_task(external_task)
|
@classmethod
def list(cls, user_id):
'Returns list of Task matching user_id, ordered by create date.'
return [Task._from_external_task(et) for et in sorted(_ExternalTask.all().filter(('%s =' % _ExternalTask.user_id.name), user_id).fetch(1000), key=(lambda task: task.create_date))]
| -169,262,631,076,434,900
|
Returns list of Task matching user_id, ordered by create date.
|
modules/balancer/balancer.py
|
list
|
ehiller/CourseBuilderV19-TeacherDashboard
|
python
|
@classmethod
def list(cls, user_id):
return [Task._from_external_task(et) for et in sorted(_ExternalTask.all().filter(('%s =' % _ExternalTask.user_id.name), user_id).fetch(1000), key=(lambda task: task.create_date))]
|
def get_ticket(self):
'Returns string identifier for the task; raises NotSavedError.'
return self.get_ticket_by_key(self.key())
| 5,212,981,061,272,546,000
|
Returns string identifier for the task; raises NotSavedError.
|
modules/balancer/balancer.py
|
get_ticket
|
ehiller/CourseBuilderV19-TeacherDashboard
|
python
|
def get_ticket(self):
return self.get_ticket_by_key(self.key())
|
def ready(self):
'True iff the operation has all data it needs to be issued.'
raise NotImplementedError
| -3,953,729,379,220,030,500
|
True iff the operation has all data it needs to be issued.
|
modules/balancer/balancer.py
|
ready
|
ehiller/CourseBuilderV19-TeacherDashboard
|
python
|
def ready(self):
raise NotImplementedError
|
@classmethod
def _transform_response(cls, response):
'Transforms worker success/error responses into a standard format.'
try:
parsed = transforms.loads(response.content)
if (not cls._check_response(parsed)):
raise ValueError
return {_PAYLOAD: parsed[_PAYLOAD]}
except:
_LOG.error(('Unable to parse worker response: ' + response.content))
return {_PAYLOAD: 'Received invalid response'}
| 8,943,993,151,239,380,000
|
Transforms worker success/error responses into a standard format.
|
modules/balancer/balancer.py
|
_transform_response
|
ehiller/CourseBuilderV19-TeacherDashboard
|
python
|
@classmethod
def _transform_response(cls, response):
try:
parsed = transforms.loads(response.content)
if (not cls._check_response(parsed)):
raise ValueError
return {_PAYLOAD: parsed[_PAYLOAD]}
except:
_LOG.error(('Unable to parse worker response: ' + response.content))
return {_PAYLOAD: 'Received invalid response'}
|
def add_entities_to_entity_group_using_post(self, entity_group_id, **kwargs):
"Add entities to the group (addEntitiesToEntityGroup) # noqa: E501\n\n Add entities to the specified entity group. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'ADD_TO_GROUP' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.add_entities_to_entity_group_using_post(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param list[str] body:\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.add_entities_to_entity_group_using_post_with_http_info(entity_group_id, **kwargs)
else:
data = self.add_entities_to_entity_group_using_post_with_http_info(entity_group_id, **kwargs)
return data
| 8,780,527,857,243,497,000
|
Add entities to the group (addEntitiesToEntityGroup) # noqa: E501
Add entities to the specified entity group. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'ADD_TO_GROUP' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.add_entities_to_entity_group_using_post(entity_group_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:param list[str] body:
:return: None
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
add_entities_to_entity_group_using_post
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def add_entities_to_entity_group_using_post(self, entity_group_id, **kwargs):
"Add entities to the group (addEntitiesToEntityGroup) # noqa: E501\n\n Add entities to the specified entity group. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'ADD_TO_GROUP' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.add_entities_to_entity_group_using_post(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param list[str] body:\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.add_entities_to_entity_group_using_post_with_http_info(entity_group_id, **kwargs)
else:
data = self.add_entities_to_entity_group_using_post_with_http_info(entity_group_id, **kwargs)
return data
|
def add_entities_to_entity_group_using_post_with_http_info(self, entity_group_id, **kwargs):
"Add entities to the group (addEntitiesToEntityGroup) # noqa: E501\n\n Add entities to the specified entity group. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'ADD_TO_GROUP' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.add_entities_to_entity_group_using_post_with_http_info(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param list[str] body:\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_group_id', 'body']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method add_entities_to_entity_group_using_post" % key))
params[key] = val
del params['kwargs']
if (('entity_group_id' not in params) or (params['entity_group_id'] is None)):
raise ValueError('Missing the required parameter `entity_group_id` when calling `add_entities_to_entity_group_using_post`')
collection_formats = {}
path_params = {}
if ('entity_group_id' in params):
path_params['entityGroupId'] = params['entity_group_id']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if ('body' in params):
body_params = params['body']
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
header_params['Content-Type'] = self.api_client.select_header_content_type(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/{entityGroupId}/addEntities', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
| 7,304,762,871,341,989,000
|
Add entities to the group (addEntitiesToEntityGroup) # noqa: E501
Add entities to the specified entity group. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'ADD_TO_GROUP' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.add_entities_to_entity_group_using_post_with_http_info(entity_group_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:param list[str] body:
:return: None
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
add_entities_to_entity_group_using_post_with_http_info
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def add_entities_to_entity_group_using_post_with_http_info(self, entity_group_id, **kwargs):
"Add entities to the group (addEntitiesToEntityGroup) # noqa: E501\n\n Add entities to the specified entity group. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'ADD_TO_GROUP' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.add_entities_to_entity_group_using_post_with_http_info(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param list[str] body:\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_group_id', 'body']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method add_entities_to_entity_group_using_post" % key))
params[key] = val
del params['kwargs']
if (('entity_group_id' not in params) or (params['entity_group_id'] is None)):
raise ValueError('Missing the required parameter `entity_group_id` when calling `add_entities_to_entity_group_using_post`')
collection_formats = {}
path_params = {}
if ('entity_group_id' in params):
path_params['entityGroupId'] = params['entity_group_id']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if ('body' in params):
body_params = params['body']
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
header_params['Content-Type'] = self.api_client.select_header_content_type(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/{entityGroupId}/addEntities', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
|
def assign_entity_group_to_edge_using_post(self, edge_id, group_type, entity_group_id, **kwargs):
"Assign entity group to edge (assignEntityGroupToEdge) # noqa: E501\n\n Creates assignment of an existing entity group to an instance of The Edge. Assignment works in async way - first, notification event pushed to edge service queue on platform. Second, remote edge service will receive a copy of assignment entity group (Edge will receive this instantly, if it's currently connected, or once it's going to be connected to platform). Third, once entity group will be delivered to edge service, edge will request entities of this group to be send to edge. Once entities will be delivered to edge service, they are going to be available for usage on remote edge instance. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.assign_entity_group_to_edge_using_post(edge_id, group_type, entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str group_type: EntityGroup type (required)\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: EntityGroup\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.assign_entity_group_to_edge_using_post_with_http_info(edge_id, group_type, entity_group_id, **kwargs)
else:
data = self.assign_entity_group_to_edge_using_post_with_http_info(edge_id, group_type, entity_group_id, **kwargs)
return data
| -4,979,035,342,014,406,000
|
Assign entity group to edge (assignEntityGroupToEdge) # noqa: E501
Creates assignment of an existing entity group to an instance of The Edge. Assignment works in async way - first, notification event pushed to edge service queue on platform. Second, remote edge service will receive a copy of assignment entity group (Edge will receive this instantly, if it's currently connected, or once it's going to be connected to platform). Third, once entity group will be delivered to edge service, edge will request entities of this group to be send to edge. Once entities will be delivered to edge service, they are going to be available for usage on remote edge instance. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for the entity (entities). # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.assign_entity_group_to_edge_using_post(edge_id, group_type, entity_group_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:param str group_type: EntityGroup type (required)
:param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:return: EntityGroup
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
assign_entity_group_to_edge_using_post
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def assign_entity_group_to_edge_using_post(self, edge_id, group_type, entity_group_id, **kwargs):
"Assign entity group to edge (assignEntityGroupToEdge) # noqa: E501\n\n Creates assignment of an existing entity group to an instance of The Edge. Assignment works in async way - first, notification event pushed to edge service queue on platform. Second, remote edge service will receive a copy of assignment entity group (Edge will receive this instantly, if it's currently connected, or once it's going to be connected to platform). Third, once entity group will be delivered to edge service, edge will request entities of this group to be send to edge. Once entities will be delivered to edge service, they are going to be available for usage on remote edge instance. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.assign_entity_group_to_edge_using_post(edge_id, group_type, entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str group_type: EntityGroup type (required)\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: EntityGroup\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.assign_entity_group_to_edge_using_post_with_http_info(edge_id, group_type, entity_group_id, **kwargs)
else:
data = self.assign_entity_group_to_edge_using_post_with_http_info(edge_id, group_type, entity_group_id, **kwargs)
return data
|
def assign_entity_group_to_edge_using_post_with_http_info(self, edge_id, group_type, entity_group_id, **kwargs):
"Assign entity group to edge (assignEntityGroupToEdge) # noqa: E501\n\n Creates assignment of an existing entity group to an instance of The Edge. Assignment works in async way - first, notification event pushed to edge service queue on platform. Second, remote edge service will receive a copy of assignment entity group (Edge will receive this instantly, if it's currently connected, or once it's going to be connected to platform). Third, once entity group will be delivered to edge service, edge will request entities of this group to be send to edge. Once entities will be delivered to edge service, they are going to be available for usage on remote edge instance. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.assign_entity_group_to_edge_using_post_with_http_info(edge_id, group_type, entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str group_type: EntityGroup type (required)\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: EntityGroup\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['edge_id', 'group_type', 'entity_group_id']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method assign_entity_group_to_edge_using_post" % key))
params[key] = val
del params['kwargs']
if (('edge_id' not in params) or (params['edge_id'] is None)):
raise ValueError('Missing the required parameter `edge_id` when calling `assign_entity_group_to_edge_using_post`')
if (('group_type' not in params) or (params['group_type'] is None)):
raise ValueError('Missing the required parameter `group_type` when calling `assign_entity_group_to_edge_using_post`')
if (('entity_group_id' not in params) or (params['entity_group_id'] is None)):
raise ValueError('Missing the required parameter `entity_group_id` when calling `assign_entity_group_to_edge_using_post`')
collection_formats = {}
path_params = {}
if ('edge_id' in params):
path_params['edgeId'] = params['edge_id']
if ('group_type' in params):
path_params['groupType'] = params['group_type']
if ('entity_group_id' in params):
path_params['entityGroupId'] = params['entity_group_id']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/edge/{edgeId}/entityGroup/{entityGroupId}/{groupType}', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='EntityGroup', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
| -2,994,785,293,451,461,600
|
Assign entity group to edge (assignEntityGroupToEdge) # noqa: E501
Creates assignment of an existing entity group to an instance of The Edge. Assignment works in async way - first, notification event pushed to edge service queue on platform. Second, remote edge service will receive a copy of assignment entity group (Edge will receive this instantly, if it's currently connected, or once it's going to be connected to platform). Third, once entity group will be delivered to edge service, edge will request entities of this group to be send to edge. Once entities will be delivered to edge service, they are going to be available for usage on remote edge instance. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for the entity (entities). # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.assign_entity_group_to_edge_using_post_with_http_info(edge_id, group_type, entity_group_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:param str group_type: EntityGroup type (required)
:param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:return: EntityGroup
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
assign_entity_group_to_edge_using_post_with_http_info
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def assign_entity_group_to_edge_using_post_with_http_info(self, edge_id, group_type, entity_group_id, **kwargs):
"Assign entity group to edge (assignEntityGroupToEdge) # noqa: E501\n\n Creates assignment of an existing entity group to an instance of The Edge. Assignment works in async way - first, notification event pushed to edge service queue on platform. Second, remote edge service will receive a copy of assignment entity group (Edge will receive this instantly, if it's currently connected, or once it's going to be connected to platform). Third, once entity group will be delivered to edge service, edge will request entities of this group to be send to edge. Once entities will be delivered to edge service, they are going to be available for usage on remote edge instance. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.assign_entity_group_to_edge_using_post_with_http_info(edge_id, group_type, entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str group_type: EntityGroup type (required)\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: EntityGroup\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['edge_id', 'group_type', 'entity_group_id']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method assign_entity_group_to_edge_using_post" % key))
params[key] = val
del params['kwargs']
if (('edge_id' not in params) or (params['edge_id'] is None)):
raise ValueError('Missing the required parameter `edge_id` when calling `assign_entity_group_to_edge_using_post`')
if (('group_type' not in params) or (params['group_type'] is None)):
raise ValueError('Missing the required parameter `group_type` when calling `assign_entity_group_to_edge_using_post`')
if (('entity_group_id' not in params) or (params['entity_group_id'] is None)):
raise ValueError('Missing the required parameter `entity_group_id` when calling `assign_entity_group_to_edge_using_post`')
collection_formats = {}
path_params = {}
if ('edge_id' in params):
path_params['edgeId'] = params['edge_id']
if ('group_type' in params):
path_params['groupType'] = params['group_type']
if ('entity_group_id' in params):
path_params['entityGroupId'] = params['entity_group_id']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/edge/{edgeId}/entityGroup/{entityGroupId}/{groupType}', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='EntityGroup', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
|
def delete_entity_group_using_delete(self, entity_group_id, **kwargs):
"Delete Entity Group (deleteEntityGroup) # noqa: E501\n\n Deletes the entity group but does not delete the entities in the group, since they are also present in reserved group 'All'. Referencing non-existing Entity Group Id will cause an error. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'DELETE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.delete_entity_group_using_delete(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.delete_entity_group_using_delete_with_http_info(entity_group_id, **kwargs)
else:
data = self.delete_entity_group_using_delete_with_http_info(entity_group_id, **kwargs)
return data
| 220,974,050,943,776,030
|
Delete Entity Group (deleteEntityGroup) # noqa: E501
Deletes the entity group but does not delete the entities in the group, since they are also present in reserved group 'All'. Referencing non-existing Entity Group Id will cause an error. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'DELETE' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_entity_group_using_delete(entity_group_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:return: None
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
delete_entity_group_using_delete
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def delete_entity_group_using_delete(self, entity_group_id, **kwargs):
"Delete Entity Group (deleteEntityGroup) # noqa: E501\n\n Deletes the entity group but does not delete the entities in the group, since they are also present in reserved group 'All'. Referencing non-existing Entity Group Id will cause an error. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'DELETE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.delete_entity_group_using_delete(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.delete_entity_group_using_delete_with_http_info(entity_group_id, **kwargs)
else:
data = self.delete_entity_group_using_delete_with_http_info(entity_group_id, **kwargs)
return data
|
def delete_entity_group_using_delete_with_http_info(self, entity_group_id, **kwargs):
"Delete Entity Group (deleteEntityGroup) # noqa: E501\n\n Deletes the entity group but does not delete the entities in the group, since they are also present in reserved group 'All'. Referencing non-existing Entity Group Id will cause an error. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'DELETE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.delete_entity_group_using_delete_with_http_info(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_group_id']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method delete_entity_group_using_delete" % key))
params[key] = val
del params['kwargs']
if (('entity_group_id' not in params) or (params['entity_group_id'] is None)):
raise ValueError('Missing the required parameter `entity_group_id` when calling `delete_entity_group_using_delete`')
collection_formats = {}
path_params = {}
if ('entity_group_id' in params):
path_params['entityGroupId'] = params['entity_group_id']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/{entityGroupId}', 'DELETE', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
| 7,306,023,280,177,708,000
|
Delete Entity Group (deleteEntityGroup) # noqa: E501
Deletes the entity group but does not delete the entities in the group, since they are also present in reserved group 'All'. Referencing non-existing Entity Group Id will cause an error. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'DELETE' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_entity_group_using_delete_with_http_info(entity_group_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:return: None
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
delete_entity_group_using_delete_with_http_info
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def delete_entity_group_using_delete_with_http_info(self, entity_group_id, **kwargs):
"Delete Entity Group (deleteEntityGroup) # noqa: E501\n\n Deletes the entity group but does not delete the entities in the group, since they are also present in reserved group 'All'. Referencing non-existing Entity Group Id will cause an error. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'DELETE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.delete_entity_group_using_delete_with_http_info(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_group_id']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method delete_entity_group_using_delete" % key))
params[key] = val
del params['kwargs']
if (('entity_group_id' not in params) or (params['entity_group_id'] is None)):
raise ValueError('Missing the required parameter `entity_group_id` when calling `delete_entity_group_using_delete`')
collection_formats = {}
path_params = {}
if ('entity_group_id' in params):
path_params['entityGroupId'] = params['entity_group_id']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/{entityGroupId}', 'DELETE', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
|
def get_all_edge_entity_groups_using_get(self, edge_id, group_type, **kwargs):
"Get All Edge Entity Groups by entity type (getAllEdgeEntityGroups) # noqa: E501\n\n Fetch the list of Entity Group Info objects based on the provided Entity Type and assigned to the provided Edge entity. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_all_edge_entity_groups_using_get(edge_id, group_type, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str group_type: EntityGroup type (required)\n :return: list[EntityGroupInfo]\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_all_edge_entity_groups_using_get_with_http_info(edge_id, group_type, **kwargs)
else:
data = self.get_all_edge_entity_groups_using_get_with_http_info(edge_id, group_type, **kwargs)
return data
| 5,369,321,702,390,439,000
|
Get All Edge Entity Groups by entity type (getAllEdgeEntityGroups) # noqa: E501
Fetch the list of Entity Group Info objects based on the provided Entity Type and assigned to the provided Edge entity. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_all_edge_entity_groups_using_get(edge_id, group_type, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:param str group_type: EntityGroup type (required)
:return: list[EntityGroupInfo]
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_all_edge_entity_groups_using_get
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_all_edge_entity_groups_using_get(self, edge_id, group_type, **kwargs):
"Get All Edge Entity Groups by entity type (getAllEdgeEntityGroups) # noqa: E501\n\n Fetch the list of Entity Group Info objects based on the provided Entity Type and assigned to the provided Edge entity. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_all_edge_entity_groups_using_get(edge_id, group_type, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str group_type: EntityGroup type (required)\n :return: list[EntityGroupInfo]\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_all_edge_entity_groups_using_get_with_http_info(edge_id, group_type, **kwargs)
else:
data = self.get_all_edge_entity_groups_using_get_with_http_info(edge_id, group_type, **kwargs)
return data
|
def get_all_edge_entity_groups_using_get_with_http_info(self, edge_id, group_type, **kwargs):
"Get All Edge Entity Groups by entity type (getAllEdgeEntityGroups) # noqa: E501\n\n Fetch the list of Entity Group Info objects based on the provided Entity Type and assigned to the provided Edge entity. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_all_edge_entity_groups_using_get_with_http_info(edge_id, group_type, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str group_type: EntityGroup type (required)\n :return: list[EntityGroupInfo]\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['edge_id', 'group_type']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_all_edge_entity_groups_using_get" % key))
params[key] = val
del params['kwargs']
if (('edge_id' not in params) or (params['edge_id'] is None)):
raise ValueError('Missing the required parameter `edge_id` when calling `get_all_edge_entity_groups_using_get`')
if (('group_type' not in params) or (params['group_type'] is None)):
raise ValueError('Missing the required parameter `group_type` when calling `get_all_edge_entity_groups_using_get`')
collection_formats = {}
path_params = {}
if ('edge_id' in params):
path_params['edgeId'] = params['edge_id']
if ('group_type' in params):
path_params['groupType'] = params['group_type']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/allEntityGroups/edge/{edgeId}/{groupType}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[EntityGroupInfo]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
| 7,866,302,978,297,372,000
|
Get All Edge Entity Groups by entity type (getAllEdgeEntityGroups) # noqa: E501
Fetch the list of Entity Group Info objects based on the provided Entity Type and assigned to the provided Edge entity. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_all_edge_entity_groups_using_get_with_http_info(edge_id, group_type, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:param str group_type: EntityGroup type (required)
:return: list[EntityGroupInfo]
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_all_edge_entity_groups_using_get_with_http_info
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_all_edge_entity_groups_using_get_with_http_info(self, edge_id, group_type, **kwargs):
"Get All Edge Entity Groups by entity type (getAllEdgeEntityGroups) # noqa: E501\n\n Fetch the list of Entity Group Info objects based on the provided Entity Type and assigned to the provided Edge entity. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_all_edge_entity_groups_using_get_with_http_info(edge_id, group_type, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str group_type: EntityGroup type (required)\n :return: list[EntityGroupInfo]\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['edge_id', 'group_type']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_all_edge_entity_groups_using_get" % key))
params[key] = val
del params['kwargs']
if (('edge_id' not in params) or (params['edge_id'] is None)):
raise ValueError('Missing the required parameter `edge_id` when calling `get_all_edge_entity_groups_using_get`')
if (('group_type' not in params) or (params['group_type'] is None)):
raise ValueError('Missing the required parameter `group_type` when calling `get_all_edge_entity_groups_using_get`')
collection_formats = {}
path_params = {}
if ('edge_id' in params):
path_params['edgeId'] = params['edge_id']
if ('group_type' in params):
path_params['groupType'] = params['group_type']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/allEntityGroups/edge/{edgeId}/{groupType}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[EntityGroupInfo]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
|
def get_edge_entity_groups_using_get(self, edge_id, group_type, page_size, page, **kwargs):
"Get Edge Entity Groups by entity type (getEdgeEntityGroups) # noqa: E501\n\n Returns a page of Entity Group Info objects based on the provided Entity Type and assigned to the provided Edge entity. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_edge_entity_groups_using_get(edge_id, group_type, page_size, page, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str group_type: EntityGroup type (required)\n :param int page_size: Maximum amount of entities in a one page (required)\n :param int page: Sequence number of page starting from 0 (required)\n :param str sort_property: Property of entity to sort by\n :param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING)\n :return: PageDataEntityGroupInfo\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_edge_entity_groups_using_get_with_http_info(edge_id, group_type, page_size, page, **kwargs)
else:
data = self.get_edge_entity_groups_using_get_with_http_info(edge_id, group_type, page_size, page, **kwargs)
return data
| 6,135,070,953,465,878,000
|
Get Edge Entity Groups by entity type (getEdgeEntityGroups) # noqa: E501
Returns a page of Entity Group Info objects based on the provided Entity Type and assigned to the provided Edge entity. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_edge_entity_groups_using_get(edge_id, group_type, page_size, page, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:param str group_type: EntityGroup type (required)
:param int page_size: Maximum amount of entities in a one page (required)
:param int page: Sequence number of page starting from 0 (required)
:param str sort_property: Property of entity to sort by
:param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING)
:return: PageDataEntityGroupInfo
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_edge_entity_groups_using_get
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_edge_entity_groups_using_get(self, edge_id, group_type, page_size, page, **kwargs):
"Get Edge Entity Groups by entity type (getEdgeEntityGroups) # noqa: E501\n\n Returns a page of Entity Group Info objects based on the provided Entity Type and assigned to the provided Edge entity. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_edge_entity_groups_using_get(edge_id, group_type, page_size, page, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str group_type: EntityGroup type (required)\n :param int page_size: Maximum amount of entities in a one page (required)\n :param int page: Sequence number of page starting from 0 (required)\n :param str sort_property: Property of entity to sort by\n :param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING)\n :return: PageDataEntityGroupInfo\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_edge_entity_groups_using_get_with_http_info(edge_id, group_type, page_size, page, **kwargs)
else:
data = self.get_edge_entity_groups_using_get_with_http_info(edge_id, group_type, page_size, page, **kwargs)
return data
|
def get_edge_entity_groups_using_get_with_http_info(self, edge_id, group_type, page_size, page, **kwargs):
"Get Edge Entity Groups by entity type (getEdgeEntityGroups) # noqa: E501\n\n Returns a page of Entity Group Info objects based on the provided Entity Type and assigned to the provided Edge entity. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_edge_entity_groups_using_get_with_http_info(edge_id, group_type, page_size, page, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str group_type: EntityGroup type (required)\n :param int page_size: Maximum amount of entities in a one page (required)\n :param int page: Sequence number of page starting from 0 (required)\n :param str sort_property: Property of entity to sort by\n :param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING)\n :return: PageDataEntityGroupInfo\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['edge_id', 'group_type', 'page_size', 'page', 'sort_property', 'sort_order']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_edge_entity_groups_using_get" % key))
params[key] = val
del params['kwargs']
if (('edge_id' not in params) or (params['edge_id'] is None)):
raise ValueError('Missing the required parameter `edge_id` when calling `get_edge_entity_groups_using_get`')
if (('group_type' not in params) or (params['group_type'] is None)):
raise ValueError('Missing the required parameter `group_type` when calling `get_edge_entity_groups_using_get`')
if (('page_size' not in params) or (params['page_size'] is None)):
raise ValueError('Missing the required parameter `page_size` when calling `get_edge_entity_groups_using_get`')
if (('page' not in params) or (params['page'] is None)):
raise ValueError('Missing the required parameter `page` when calling `get_edge_entity_groups_using_get`')
collection_formats = {}
path_params = {}
if ('edge_id' in params):
path_params['edgeId'] = params['edge_id']
if ('group_type' in params):
path_params['groupType'] = params['group_type']
query_params = []
if ('page_size' in params):
query_params.append(('pageSize', params['page_size']))
if ('page' in params):
query_params.append(('page', params['page']))
if ('sort_property' in params):
query_params.append(('sortProperty', params['sort_property']))
if ('sort_order' in params):
query_params.append(('sortOrder', params['sort_order']))
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroups/edge/{edgeId}/{groupType}{?page,pageSize,sortOrder,sortProperty}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='PageDataEntityGroupInfo', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
| -5,542,060,722,140,155,000
|
Get Edge Entity Groups by entity type (getEdgeEntityGroups) # noqa: E501
Returns a page of Entity Group Info objects based on the provided Entity Type and assigned to the provided Edge entity. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_edge_entity_groups_using_get_with_http_info(edge_id, group_type, page_size, page, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:param str group_type: EntityGroup type (required)
:param int page_size: Maximum amount of entities in a one page (required)
:param int page: Sequence number of page starting from 0 (required)
:param str sort_property: Property of entity to sort by
:param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING)
:return: PageDataEntityGroupInfo
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_edge_entity_groups_using_get_with_http_info
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_edge_entity_groups_using_get_with_http_info(self, edge_id, group_type, page_size, page, **kwargs):
"Get Edge Entity Groups by entity type (getEdgeEntityGroups) # noqa: E501\n\n Returns a page of Entity Group Info objects based on the provided Entity Type and assigned to the provided Edge entity. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_edge_entity_groups_using_get_with_http_info(edge_id, group_type, page_size, page, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str group_type: EntityGroup type (required)\n :param int page_size: Maximum amount of entities in a one page (required)\n :param int page: Sequence number of page starting from 0 (required)\n :param str sort_property: Property of entity to sort by\n :param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING)\n :return: PageDataEntityGroupInfo\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['edge_id', 'group_type', 'page_size', 'page', 'sort_property', 'sort_order']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_edge_entity_groups_using_get" % key))
params[key] = val
del params['kwargs']
if (('edge_id' not in params) or (params['edge_id'] is None)):
raise ValueError('Missing the required parameter `edge_id` when calling `get_edge_entity_groups_using_get`')
if (('group_type' not in params) or (params['group_type'] is None)):
raise ValueError('Missing the required parameter `group_type` when calling `get_edge_entity_groups_using_get`')
if (('page_size' not in params) or (params['page_size'] is None)):
raise ValueError('Missing the required parameter `page_size` when calling `get_edge_entity_groups_using_get`')
if (('page' not in params) or (params['page'] is None)):
raise ValueError('Missing the required parameter `page` when calling `get_edge_entity_groups_using_get`')
collection_formats = {}
path_params = {}
if ('edge_id' in params):
path_params['edgeId'] = params['edge_id']
if ('group_type' in params):
path_params['groupType'] = params['group_type']
query_params = []
if ('page_size' in params):
query_params.append(('pageSize', params['page_size']))
if ('page' in params):
query_params.append(('page', params['page']))
if ('sort_property' in params):
query_params.append(('sortProperty', params['sort_property']))
if ('sort_order' in params):
query_params.append(('sortOrder', params['sort_order']))
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroups/edge/{edgeId}/{groupType}{?page,pageSize,sortOrder,sortProperty}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='PageDataEntityGroupInfo', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
|
def get_entities_using_get(self, entity_group_id, page_size, page, **kwargs):
"Get Group Entities (getEntities) # noqa: E501\n\n Returns a page of Short Entity View objects that belongs to specified Entity Group Id. Short Entity View object contains the entity id and number of fields (attributes, telemetry, etc). List of those fields is configurable and defined in the group configuration.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entities_using_get(entity_group_id, page_size, page, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param int page_size: Maximum amount of entities in a one page (required)\n :param int page: Sequence number of page starting from 0 (required)\n :param str text_search: The case insensitive 'startsWith' filter based on the entity group name.\n :param str sort_property: Property of entity to sort by\n :param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING)\n :return: PageDataShortEntityView\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_entities_using_get_with_http_info(entity_group_id, page_size, page, **kwargs)
else:
data = self.get_entities_using_get_with_http_info(entity_group_id, page_size, page, **kwargs)
return data
| -8,534,619,707,369,640,000
|
Get Group Entities (getEntities) # noqa: E501
Returns a page of Short Entity View objects that belongs to specified Entity Group Id. Short Entity View object contains the entity id and number of fields (attributes, telemetry, etc). List of those fields is configurable and defined in the group configuration.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_entities_using_get(entity_group_id, page_size, page, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:param int page_size: Maximum amount of entities in a one page (required)
:param int page: Sequence number of page starting from 0 (required)
:param str text_search: The case insensitive 'startsWith' filter based on the entity group name.
:param str sort_property: Property of entity to sort by
:param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING)
:return: PageDataShortEntityView
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_entities_using_get
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_entities_using_get(self, entity_group_id, page_size, page, **kwargs):
"Get Group Entities (getEntities) # noqa: E501\n\n Returns a page of Short Entity View objects that belongs to specified Entity Group Id. Short Entity View object contains the entity id and number of fields (attributes, telemetry, etc). List of those fields is configurable and defined in the group configuration.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entities_using_get(entity_group_id, page_size, page, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param int page_size: Maximum amount of entities in a one page (required)\n :param int page: Sequence number of page starting from 0 (required)\n :param str text_search: The case insensitive 'startsWith' filter based on the entity group name.\n :param str sort_property: Property of entity to sort by\n :param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING)\n :return: PageDataShortEntityView\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_entities_using_get_with_http_info(entity_group_id, page_size, page, **kwargs)
else:
data = self.get_entities_using_get_with_http_info(entity_group_id, page_size, page, **kwargs)
return data
|
def get_entities_using_get_with_http_info(self, entity_group_id, page_size, page, **kwargs):
"Get Group Entities (getEntities) # noqa: E501\n\n Returns a page of Short Entity View objects that belongs to specified Entity Group Id. Short Entity View object contains the entity id and number of fields (attributes, telemetry, etc). List of those fields is configurable and defined in the group configuration.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entities_using_get_with_http_info(entity_group_id, page_size, page, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param int page_size: Maximum amount of entities in a one page (required)\n :param int page: Sequence number of page starting from 0 (required)\n :param str text_search: The case insensitive 'startsWith' filter based on the entity group name.\n :param str sort_property: Property of entity to sort by\n :param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING)\n :return: PageDataShortEntityView\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_group_id', 'page_size', 'page', 'text_search', 'sort_property', 'sort_order']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_entities_using_get" % key))
params[key] = val
del params['kwargs']
if (('entity_group_id' not in params) or (params['entity_group_id'] is None)):
raise ValueError('Missing the required parameter `entity_group_id` when calling `get_entities_using_get`')
if (('page_size' not in params) or (params['page_size'] is None)):
raise ValueError('Missing the required parameter `page_size` when calling `get_entities_using_get`')
if (('page' not in params) or (params['page'] is None)):
raise ValueError('Missing the required parameter `page` when calling `get_entities_using_get`')
collection_formats = {}
path_params = {}
if ('entity_group_id' in params):
path_params['entityGroupId'] = params['entity_group_id']
query_params = []
if ('page_size' in params):
query_params.append(('pageSize', params['page_size']))
if ('page' in params):
query_params.append(('page', params['page']))
if ('text_search' in params):
query_params.append(('textSearch', params['text_search']))
if ('sort_property' in params):
query_params.append(('sortProperty', params['sort_property']))
if ('sort_order' in params):
query_params.append(('sortOrder', params['sort_order']))
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/{entityGroupId}/entities{?page,pageSize,sortOrder,sortProperty,textSearch}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='PageDataShortEntityView', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
| -3,965,570,583,084,288,000
|
Get Group Entities (getEntities) # noqa: E501
Returns a page of Short Entity View objects that belongs to specified Entity Group Id. Short Entity View object contains the entity id and number of fields (attributes, telemetry, etc). List of those fields is configurable and defined in the group configuration.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_entities_using_get_with_http_info(entity_group_id, page_size, page, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:param int page_size: Maximum amount of entities in a one page (required)
:param int page: Sequence number of page starting from 0 (required)
:param str text_search: The case insensitive 'startsWith' filter based on the entity group name.
:param str sort_property: Property of entity to sort by
:param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING)
:return: PageDataShortEntityView
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_entities_using_get_with_http_info
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_entities_using_get_with_http_info(self, entity_group_id, page_size, page, **kwargs):
"Get Group Entities (getEntities) # noqa: E501\n\n Returns a page of Short Entity View objects that belongs to specified Entity Group Id. Short Entity View object contains the entity id and number of fields (attributes, telemetry, etc). List of those fields is configurable and defined in the group configuration.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entities_using_get_with_http_info(entity_group_id, page_size, page, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param int page_size: Maximum amount of entities in a one page (required)\n :param int page: Sequence number of page starting from 0 (required)\n :param str text_search: The case insensitive 'startsWith' filter based on the entity group name.\n :param str sort_property: Property of entity to sort by\n :param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING)\n :return: PageDataShortEntityView\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_group_id', 'page_size', 'page', 'text_search', 'sort_property', 'sort_order']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_entities_using_get" % key))
params[key] = val
del params['kwargs']
if (('entity_group_id' not in params) or (params['entity_group_id'] is None)):
raise ValueError('Missing the required parameter `entity_group_id` when calling `get_entities_using_get`')
if (('page_size' not in params) or (params['page_size'] is None)):
raise ValueError('Missing the required parameter `page_size` when calling `get_entities_using_get`')
if (('page' not in params) or (params['page'] is None)):
raise ValueError('Missing the required parameter `page` when calling `get_entities_using_get`')
collection_formats = {}
path_params = {}
if ('entity_group_id' in params):
path_params['entityGroupId'] = params['entity_group_id']
query_params = []
if ('page_size' in params):
query_params.append(('pageSize', params['page_size']))
if ('page' in params):
query_params.append(('page', params['page']))
if ('text_search' in params):
query_params.append(('textSearch', params['text_search']))
if ('sort_property' in params):
query_params.append(('sortProperty', params['sort_property']))
if ('sort_order' in params):
query_params.append(('sortOrder', params['sort_order']))
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/{entityGroupId}/entities{?page,pageSize,sortOrder,sortProperty,textSearch}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='PageDataShortEntityView', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
|
def get_entity_group_all_by_owner_and_type_using_get(self, owner_type, owner_id, group_type, **kwargs):
"Get special group All by owner and entity type (getEntityGroupsByOwnerAndType) # noqa: E501\n\n Fetch reserved group 'All' based on the provided Owner Id and Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_group_all_by_owner_and_type_using_get(owner_type, owner_id, group_type, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str owner_type: Tenant or Customer (required)\n :param str owner_id: A string value representing the Tenant or Customer id (required)\n :param str group_type: Entity Group type (required)\n :return: EntityGroupInfo\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_entity_group_all_by_owner_and_type_using_get_with_http_info(owner_type, owner_id, group_type, **kwargs)
else:
data = self.get_entity_group_all_by_owner_and_type_using_get_with_http_info(owner_type, owner_id, group_type, **kwargs)
return data
| 6,431,286,293,067,816,000
|
Get special group All by owner and entity type (getEntityGroupsByOwnerAndType) # noqa: E501
Fetch reserved group 'All' based on the provided Owner Id and Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_entity_group_all_by_owner_and_type_using_get(owner_type, owner_id, group_type, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str owner_type: Tenant or Customer (required)
:param str owner_id: A string value representing the Tenant or Customer id (required)
:param str group_type: Entity Group type (required)
:return: EntityGroupInfo
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_entity_group_all_by_owner_and_type_using_get
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_entity_group_all_by_owner_and_type_using_get(self, owner_type, owner_id, group_type, **kwargs):
"Get special group All by owner and entity type (getEntityGroupsByOwnerAndType) # noqa: E501\n\n Fetch reserved group 'All' based on the provided Owner Id and Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_group_all_by_owner_and_type_using_get(owner_type, owner_id, group_type, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str owner_type: Tenant or Customer (required)\n :param str owner_id: A string value representing the Tenant or Customer id (required)\n :param str group_type: Entity Group type (required)\n :return: EntityGroupInfo\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_entity_group_all_by_owner_and_type_using_get_with_http_info(owner_type, owner_id, group_type, **kwargs)
else:
data = self.get_entity_group_all_by_owner_and_type_using_get_with_http_info(owner_type, owner_id, group_type, **kwargs)
return data
|
def get_entity_group_all_by_owner_and_type_using_get_with_http_info(self, owner_type, owner_id, group_type, **kwargs):
"Get special group All by owner and entity type (getEntityGroupsByOwnerAndType) # noqa: E501\n\n Fetch reserved group 'All' based on the provided Owner Id and Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_group_all_by_owner_and_type_using_get_with_http_info(owner_type, owner_id, group_type, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str owner_type: Tenant or Customer (required)\n :param str owner_id: A string value representing the Tenant or Customer id (required)\n :param str group_type: Entity Group type (required)\n :return: EntityGroupInfo\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['owner_type', 'owner_id', 'group_type']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_entity_group_all_by_owner_and_type_using_get" % key))
params[key] = val
del params['kwargs']
if (('owner_type' not in params) or (params['owner_type'] is None)):
raise ValueError('Missing the required parameter `owner_type` when calling `get_entity_group_all_by_owner_and_type_using_get`')
if (('owner_id' not in params) or (params['owner_id'] is None)):
raise ValueError('Missing the required parameter `owner_id` when calling `get_entity_group_all_by_owner_and_type_using_get`')
if (('group_type' not in params) or (params['group_type'] is None)):
raise ValueError('Missing the required parameter `group_type` when calling `get_entity_group_all_by_owner_and_type_using_get`')
collection_formats = {}
path_params = {}
if ('owner_type' in params):
path_params['ownerType'] = params['owner_type']
if ('owner_id' in params):
path_params['ownerId'] = params['owner_id']
if ('group_type' in params):
path_params['groupType'] = params['group_type']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/all/{ownerType}/{ownerId}/{groupType}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='EntityGroupInfo', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
| -5,288,811,081,803,652,000
|
Get special group All by owner and entity type (getEntityGroupsByOwnerAndType) # noqa: E501
Fetch reserved group 'All' based on the provided Owner Id and Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_entity_group_all_by_owner_and_type_using_get_with_http_info(owner_type, owner_id, group_type, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str owner_type: Tenant or Customer (required)
:param str owner_id: A string value representing the Tenant or Customer id (required)
:param str group_type: Entity Group type (required)
:return: EntityGroupInfo
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_entity_group_all_by_owner_and_type_using_get_with_http_info
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_entity_group_all_by_owner_and_type_using_get_with_http_info(self, owner_type, owner_id, group_type, **kwargs):
"Get special group All by owner and entity type (getEntityGroupsByOwnerAndType) # noqa: E501\n\n Fetch reserved group 'All' based on the provided Owner Id and Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_group_all_by_owner_and_type_using_get_with_http_info(owner_type, owner_id, group_type, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str owner_type: Tenant or Customer (required)\n :param str owner_id: A string value representing the Tenant or Customer id (required)\n :param str group_type: Entity Group type (required)\n :return: EntityGroupInfo\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['owner_type', 'owner_id', 'group_type']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_entity_group_all_by_owner_and_type_using_get" % key))
params[key] = val
del params['kwargs']
if (('owner_type' not in params) or (params['owner_type'] is None)):
raise ValueError('Missing the required parameter `owner_type` when calling `get_entity_group_all_by_owner_and_type_using_get`')
if (('owner_id' not in params) or (params['owner_id'] is None)):
raise ValueError('Missing the required parameter `owner_id` when calling `get_entity_group_all_by_owner_and_type_using_get`')
if (('group_type' not in params) or (params['group_type'] is None)):
raise ValueError('Missing the required parameter `group_type` when calling `get_entity_group_all_by_owner_and_type_using_get`')
collection_formats = {}
path_params = {}
if ('owner_type' in params):
path_params['ownerType'] = params['owner_type']
if ('owner_id' in params):
path_params['ownerId'] = params['owner_id']
if ('group_type' in params):
path_params['groupType'] = params['group_type']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/all/{ownerType}/{ownerId}/{groupType}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='EntityGroupInfo', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
|
def get_entity_group_by_id_using_get(self, entity_group_id, **kwargs):
"Get Entity Group Info (getEntityGroupById) # noqa: E501\n\n Fetch the Entity Group object based on the provided Entity Group Id. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_group_by_id_using_get(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: EntityGroupInfo\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_entity_group_by_id_using_get_with_http_info(entity_group_id, **kwargs)
else:
data = self.get_entity_group_by_id_using_get_with_http_info(entity_group_id, **kwargs)
return data
| -1,153,845,621,197,559,800
|
Get Entity Group Info (getEntityGroupById) # noqa: E501
Fetch the Entity Group object based on the provided Entity Group Id. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_entity_group_by_id_using_get(entity_group_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:return: EntityGroupInfo
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_entity_group_by_id_using_get
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_entity_group_by_id_using_get(self, entity_group_id, **kwargs):
"Get Entity Group Info (getEntityGroupById) # noqa: E501\n\n Fetch the Entity Group object based on the provided Entity Group Id. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_group_by_id_using_get(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: EntityGroupInfo\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_entity_group_by_id_using_get_with_http_info(entity_group_id, **kwargs)
else:
data = self.get_entity_group_by_id_using_get_with_http_info(entity_group_id, **kwargs)
return data
|
def get_entity_group_by_id_using_get_with_http_info(self, entity_group_id, **kwargs):
"Get Entity Group Info (getEntityGroupById) # noqa: E501\n\n Fetch the Entity Group object based on the provided Entity Group Id. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_group_by_id_using_get_with_http_info(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: EntityGroupInfo\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_group_id']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_entity_group_by_id_using_get" % key))
params[key] = val
del params['kwargs']
if (('entity_group_id' not in params) or (params['entity_group_id'] is None)):
raise ValueError('Missing the required parameter `entity_group_id` when calling `get_entity_group_by_id_using_get`')
collection_formats = {}
path_params = {}
if ('entity_group_id' in params):
path_params['entityGroupId'] = params['entity_group_id']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/{entityGroupId}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='EntityGroupInfo', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
| -7,262,955,596,366,457,000
|
Get Entity Group Info (getEntityGroupById) # noqa: E501
Fetch the Entity Group object based on the provided Entity Group Id. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_entity_group_by_id_using_get_with_http_info(entity_group_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:return: EntityGroupInfo
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_entity_group_by_id_using_get_with_http_info
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_entity_group_by_id_using_get_with_http_info(self, entity_group_id, **kwargs):
"Get Entity Group Info (getEntityGroupById) # noqa: E501\n\n Fetch the Entity Group object based on the provided Entity Group Id. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_group_by_id_using_get_with_http_info(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: EntityGroupInfo\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_group_id']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_entity_group_by_id_using_get" % key))
params[key] = val
del params['kwargs']
if (('entity_group_id' not in params) or (params['entity_group_id'] is None)):
raise ValueError('Missing the required parameter `entity_group_id` when calling `get_entity_group_by_id_using_get`')
collection_formats = {}
path_params = {}
if ('entity_group_id' in params):
path_params['entityGroupId'] = params['entity_group_id']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/{entityGroupId}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='EntityGroupInfo', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
|
def get_entity_group_by_owner_and_name_and_type_using_get(self, owner_type, owner_id, group_type, group_name, **kwargs):
"Get Entity Group by owner, type and name (getEntityGroupByOwnerAndNameAndType) # noqa: E501\n\n Fetch the Entity Group object based on the provided Entity Group Id. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_group_by_owner_and_name_and_type_using_get(owner_type, owner_id, group_type, group_name, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str owner_type: Tenant or Customer (required)\n :param str owner_id: A string value representing the Tenant or Customer id (required)\n :param str group_type: Entity Group type (required)\n :param str group_name: Entity Group name (required)\n :return: EntityGroupInfo\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_entity_group_by_owner_and_name_and_type_using_get_with_http_info(owner_type, owner_id, group_type, group_name, **kwargs)
else:
data = self.get_entity_group_by_owner_and_name_and_type_using_get_with_http_info(owner_type, owner_id, group_type, group_name, **kwargs)
return data
| -7,671,892,698,928,798,000
|
Get Entity Group by owner, type and name (getEntityGroupByOwnerAndNameAndType) # noqa: E501
Fetch the Entity Group object based on the provided Entity Group Id. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_entity_group_by_owner_and_name_and_type_using_get(owner_type, owner_id, group_type, group_name, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str owner_type: Tenant or Customer (required)
:param str owner_id: A string value representing the Tenant or Customer id (required)
:param str group_type: Entity Group type (required)
:param str group_name: Entity Group name (required)
:return: EntityGroupInfo
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_entity_group_by_owner_and_name_and_type_using_get
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_entity_group_by_owner_and_name_and_type_using_get(self, owner_type, owner_id, group_type, group_name, **kwargs):
"Get Entity Group by owner, type and name (getEntityGroupByOwnerAndNameAndType) # noqa: E501\n\n Fetch the Entity Group object based on the provided Entity Group Id. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_group_by_owner_and_name_and_type_using_get(owner_type, owner_id, group_type, group_name, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str owner_type: Tenant or Customer (required)\n :param str owner_id: A string value representing the Tenant or Customer id (required)\n :param str group_type: Entity Group type (required)\n :param str group_name: Entity Group name (required)\n :return: EntityGroupInfo\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_entity_group_by_owner_and_name_and_type_using_get_with_http_info(owner_type, owner_id, group_type, group_name, **kwargs)
else:
data = self.get_entity_group_by_owner_and_name_and_type_using_get_with_http_info(owner_type, owner_id, group_type, group_name, **kwargs)
return data
|
def get_entity_group_by_owner_and_name_and_type_using_get_with_http_info(self, owner_type, owner_id, group_type, group_name, **kwargs):
"Get Entity Group by owner, type and name (getEntityGroupByOwnerAndNameAndType) # noqa: E501\n\n Fetch the Entity Group object based on the provided Entity Group Id. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_group_by_owner_and_name_and_type_using_get_with_http_info(owner_type, owner_id, group_type, group_name, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str owner_type: Tenant or Customer (required)\n :param str owner_id: A string value representing the Tenant or Customer id (required)\n :param str group_type: Entity Group type (required)\n :param str group_name: Entity Group name (required)\n :return: EntityGroupInfo\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['owner_type', 'owner_id', 'group_type', 'group_name']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_entity_group_by_owner_and_name_and_type_using_get" % key))
params[key] = val
del params['kwargs']
if (('owner_type' not in params) or (params['owner_type'] is None)):
raise ValueError('Missing the required parameter `owner_type` when calling `get_entity_group_by_owner_and_name_and_type_using_get`')
if (('owner_id' not in params) or (params['owner_id'] is None)):
raise ValueError('Missing the required parameter `owner_id` when calling `get_entity_group_by_owner_and_name_and_type_using_get`')
if (('group_type' not in params) or (params['group_type'] is None)):
raise ValueError('Missing the required parameter `group_type` when calling `get_entity_group_by_owner_and_name_and_type_using_get`')
if (('group_name' not in params) or (params['group_name'] is None)):
raise ValueError('Missing the required parameter `group_name` when calling `get_entity_group_by_owner_and_name_and_type_using_get`')
collection_formats = {}
path_params = {}
if ('owner_type' in params):
path_params['ownerType'] = params['owner_type']
if ('owner_id' in params):
path_params['ownerId'] = params['owner_id']
if ('group_type' in params):
path_params['groupType'] = params['group_type']
if ('group_name' in params):
path_params['groupName'] = params['group_name']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/{ownerType}/{ownerId}/{groupType}/{groupName}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='EntityGroupInfo', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
| -4,812,204,112,726,170,000
|
Get Entity Group by owner, type and name (getEntityGroupByOwnerAndNameAndType) # noqa: E501
Fetch the Entity Group object based on the provided Entity Group Id. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_entity_group_by_owner_and_name_and_type_using_get_with_http_info(owner_type, owner_id, group_type, group_name, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str owner_type: Tenant or Customer (required)
:param str owner_id: A string value representing the Tenant or Customer id (required)
:param str group_type: Entity Group type (required)
:param str group_name: Entity Group name (required)
:return: EntityGroupInfo
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_entity_group_by_owner_and_name_and_type_using_get_with_http_info
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_entity_group_by_owner_and_name_and_type_using_get_with_http_info(self, owner_type, owner_id, group_type, group_name, **kwargs):
"Get Entity Group by owner, type and name (getEntityGroupByOwnerAndNameAndType) # noqa: E501\n\n Fetch the Entity Group object based on the provided Entity Group Id. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_group_by_owner_and_name_and_type_using_get_with_http_info(owner_type, owner_id, group_type, group_name, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str owner_type: Tenant or Customer (required)\n :param str owner_id: A string value representing the Tenant or Customer id (required)\n :param str group_type: Entity Group type (required)\n :param str group_name: Entity Group name (required)\n :return: EntityGroupInfo\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['owner_type', 'owner_id', 'group_type', 'group_name']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_entity_group_by_owner_and_name_and_type_using_get" % key))
params[key] = val
del params['kwargs']
if (('owner_type' not in params) or (params['owner_type'] is None)):
raise ValueError('Missing the required parameter `owner_type` when calling `get_entity_group_by_owner_and_name_and_type_using_get`')
if (('owner_id' not in params) or (params['owner_id'] is None)):
raise ValueError('Missing the required parameter `owner_id` when calling `get_entity_group_by_owner_and_name_and_type_using_get`')
if (('group_type' not in params) or (params['group_type'] is None)):
raise ValueError('Missing the required parameter `group_type` when calling `get_entity_group_by_owner_and_name_and_type_using_get`')
if (('group_name' not in params) or (params['group_name'] is None)):
raise ValueError('Missing the required parameter `group_name` when calling `get_entity_group_by_owner_and_name_and_type_using_get`')
collection_formats = {}
path_params = {}
if ('owner_type' in params):
path_params['ownerType'] = params['owner_type']
if ('owner_id' in params):
path_params['ownerId'] = params['owner_id']
if ('group_type' in params):
path_params['groupType'] = params['group_type']
if ('group_name' in params):
path_params['groupName'] = params['group_name']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/{ownerType}/{ownerId}/{groupType}/{groupName}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='EntityGroupInfo', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
|
def get_entity_groups_by_ids_using_get(self, entity_group_ids, **kwargs):
"Get Entity Groups by Ids (getDevicesByIds) # noqa: E501\n\n Requested devices must be owned by tenant or assigned to customer which user is performing the request. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_groups_by_ids_using_get(entity_group_ids, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_ids: A list of group ids, separated by comma ',' (required)\n :return: list[EntityGroup]\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_entity_groups_by_ids_using_get_with_http_info(entity_group_ids, **kwargs)
else:
data = self.get_entity_groups_by_ids_using_get_with_http_info(entity_group_ids, **kwargs)
return data
| 5,126,398,293,684,405,000
|
Get Entity Groups by Ids (getDevicesByIds) # noqa: E501
Requested devices must be owned by tenant or assigned to customer which user is performing the request. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_entity_groups_by_ids_using_get(entity_group_ids, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_group_ids: A list of group ids, separated by comma ',' (required)
:return: list[EntityGroup]
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_entity_groups_by_ids_using_get
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_entity_groups_by_ids_using_get(self, entity_group_ids, **kwargs):
"Get Entity Groups by Ids (getDevicesByIds) # noqa: E501\n\n Requested devices must be owned by tenant or assigned to customer which user is performing the request. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_groups_by_ids_using_get(entity_group_ids, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_ids: A list of group ids, separated by comma ',' (required)\n :return: list[EntityGroup]\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_entity_groups_by_ids_using_get_with_http_info(entity_group_ids, **kwargs)
else:
data = self.get_entity_groups_by_ids_using_get_with_http_info(entity_group_ids, **kwargs)
return data
|
def get_entity_groups_by_ids_using_get_with_http_info(self, entity_group_ids, **kwargs):
"Get Entity Groups by Ids (getDevicesByIds) # noqa: E501\n\n Requested devices must be owned by tenant or assigned to customer which user is performing the request. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_groups_by_ids_using_get_with_http_info(entity_group_ids, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_ids: A list of group ids, separated by comma ',' (required)\n :return: list[EntityGroup]\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_group_ids']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_entity_groups_by_ids_using_get" % key))
params[key] = val
del params['kwargs']
if (('entity_group_ids' not in params) or (params['entity_group_ids'] is None)):
raise ValueError('Missing the required parameter `entity_group_ids` when calling `get_entity_groups_by_ids_using_get`')
collection_formats = {}
path_params = {}
query_params = []
if ('entity_group_ids' in params):
query_params.append(('entityGroupIds', params['entity_group_ids']))
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroups{?entityGroupIds}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[EntityGroup]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
| -8,986,001,988,858,836,000
|
Get Entity Groups by Ids (getDevicesByIds) # noqa: E501
Requested devices must be owned by tenant or assigned to customer which user is performing the request. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_entity_groups_by_ids_using_get_with_http_info(entity_group_ids, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_group_ids: A list of group ids, separated by comma ',' (required)
:return: list[EntityGroup]
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_entity_groups_by_ids_using_get_with_http_info
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_entity_groups_by_ids_using_get_with_http_info(self, entity_group_ids, **kwargs):
"Get Entity Groups by Ids (getDevicesByIds) # noqa: E501\n\n Requested devices must be owned by tenant or assigned to customer which user is performing the request. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_groups_by_ids_using_get_with_http_info(entity_group_ids, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_ids: A list of group ids, separated by comma ',' (required)\n :return: list[EntityGroup]\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_group_ids']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_entity_groups_by_ids_using_get" % key))
params[key] = val
del params['kwargs']
if (('entity_group_ids' not in params) or (params['entity_group_ids'] is None)):
raise ValueError('Missing the required parameter `entity_group_ids` when calling `get_entity_groups_by_ids_using_get`')
collection_formats = {}
path_params = {}
query_params = []
if ('entity_group_ids' in params):
query_params.append(('entityGroupIds', params['entity_group_ids']))
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroups{?entityGroupIds}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[EntityGroup]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
|
def get_entity_groups_by_owner_and_type_using_get(self, owner_type, owner_id, group_type, **kwargs):
"Get Entity Groups by owner and entity type (getEntityGroupsByOwnerAndType) # noqa: E501\n\n Fetch the list of Entity Group Info objects based on the provided Owner Id and Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_groups_by_owner_and_type_using_get(owner_type, owner_id, group_type, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str owner_type: Tenant or Customer (required)\n :param str owner_id: A string value representing the Tenant or Customer id (required)\n :param str group_type: Entity Group type (required)\n :return: list[EntityGroupInfo]\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_entity_groups_by_owner_and_type_using_get_with_http_info(owner_type, owner_id, group_type, **kwargs)
else:
data = self.get_entity_groups_by_owner_and_type_using_get_with_http_info(owner_type, owner_id, group_type, **kwargs)
return data
| -4,102,959,296,413,253,600
|
Get Entity Groups by owner and entity type (getEntityGroupsByOwnerAndType) # noqa: E501
Fetch the list of Entity Group Info objects based on the provided Owner Id and Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_entity_groups_by_owner_and_type_using_get(owner_type, owner_id, group_type, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str owner_type: Tenant or Customer (required)
:param str owner_id: A string value representing the Tenant or Customer id (required)
:param str group_type: Entity Group type (required)
:return: list[EntityGroupInfo]
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_entity_groups_by_owner_and_type_using_get
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_entity_groups_by_owner_and_type_using_get(self, owner_type, owner_id, group_type, **kwargs):
"Get Entity Groups by owner and entity type (getEntityGroupsByOwnerAndType) # noqa: E501\n\n Fetch the list of Entity Group Info objects based on the provided Owner Id and Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_groups_by_owner_and_type_using_get(owner_type, owner_id, group_type, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str owner_type: Tenant or Customer (required)\n :param str owner_id: A string value representing the Tenant or Customer id (required)\n :param str group_type: Entity Group type (required)\n :return: list[EntityGroupInfo]\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_entity_groups_by_owner_and_type_using_get_with_http_info(owner_type, owner_id, group_type, **kwargs)
else:
data = self.get_entity_groups_by_owner_and_type_using_get_with_http_info(owner_type, owner_id, group_type, **kwargs)
return data
|
def get_entity_groups_by_owner_and_type_using_get_with_http_info(self, owner_type, owner_id, group_type, **kwargs):
"Get Entity Groups by owner and entity type (getEntityGroupsByOwnerAndType) # noqa: E501\n\n Fetch the list of Entity Group Info objects based on the provided Owner Id and Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_groups_by_owner_and_type_using_get_with_http_info(owner_type, owner_id, group_type, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str owner_type: Tenant or Customer (required)\n :param str owner_id: A string value representing the Tenant or Customer id (required)\n :param str group_type: Entity Group type (required)\n :return: list[EntityGroupInfo]\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['owner_type', 'owner_id', 'group_type']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_entity_groups_by_owner_and_type_using_get" % key))
params[key] = val
del params['kwargs']
if (('owner_type' not in params) or (params['owner_type'] is None)):
raise ValueError('Missing the required parameter `owner_type` when calling `get_entity_groups_by_owner_and_type_using_get`')
if (('owner_id' not in params) or (params['owner_id'] is None)):
raise ValueError('Missing the required parameter `owner_id` when calling `get_entity_groups_by_owner_and_type_using_get`')
if (('group_type' not in params) or (params['group_type'] is None)):
raise ValueError('Missing the required parameter `group_type` when calling `get_entity_groups_by_owner_and_type_using_get`')
collection_formats = {}
path_params = {}
if ('owner_type' in params):
path_params['ownerType'] = params['owner_type']
if ('owner_id' in params):
path_params['ownerId'] = params['owner_id']
if ('group_type' in params):
path_params['groupType'] = params['group_type']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroups/{ownerType}/{ownerId}/{groupType}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[EntityGroupInfo]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
| -6,193,355,462,377,069,000
|
Get Entity Groups by owner and entity type (getEntityGroupsByOwnerAndType) # noqa: E501
Fetch the list of Entity Group Info objects based on the provided Owner Id and Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_entity_groups_by_owner_and_type_using_get_with_http_info(owner_type, owner_id, group_type, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str owner_type: Tenant or Customer (required)
:param str owner_id: A string value representing the Tenant or Customer id (required)
:param str group_type: Entity Group type (required)
:return: list[EntityGroupInfo]
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_entity_groups_by_owner_and_type_using_get_with_http_info
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_entity_groups_by_owner_and_type_using_get_with_http_info(self, owner_type, owner_id, group_type, **kwargs):
"Get Entity Groups by owner and entity type (getEntityGroupsByOwnerAndType) # noqa: E501\n\n Fetch the list of Entity Group Info objects based on the provided Owner Id and Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_groups_by_owner_and_type_using_get_with_http_info(owner_type, owner_id, group_type, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str owner_type: Tenant or Customer (required)\n :param str owner_id: A string value representing the Tenant or Customer id (required)\n :param str group_type: Entity Group type (required)\n :return: list[EntityGroupInfo]\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['owner_type', 'owner_id', 'group_type']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_entity_groups_by_owner_and_type_using_get" % key))
params[key] = val
del params['kwargs']
if (('owner_type' not in params) or (params['owner_type'] is None)):
raise ValueError('Missing the required parameter `owner_type` when calling `get_entity_groups_by_owner_and_type_using_get`')
if (('owner_id' not in params) or (params['owner_id'] is None)):
raise ValueError('Missing the required parameter `owner_id` when calling `get_entity_groups_by_owner_and_type_using_get`')
if (('group_type' not in params) or (params['group_type'] is None)):
raise ValueError('Missing the required parameter `group_type` when calling `get_entity_groups_by_owner_and_type_using_get`')
collection_formats = {}
path_params = {}
if ('owner_type' in params):
path_params['ownerType'] = params['owner_type']
if ('owner_id' in params):
path_params['ownerId'] = params['owner_id']
if ('group_type' in params):
path_params['groupType'] = params['group_type']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroups/{ownerType}/{ownerId}/{groupType}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[EntityGroupInfo]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
|
def get_entity_groups_by_type_using_get(self, group_type, **kwargs):
"Get Entity Groups by entity type (getEntityGroupsByType) # noqa: E501\n\n Fetch the list of Entity Group Info objects based on the provided Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_groups_by_type_using_get(group_type, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str group_type: Entity Group type (required)\n :return: list[EntityGroupInfo]\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_entity_groups_by_type_using_get_with_http_info(group_type, **kwargs)
else:
data = self.get_entity_groups_by_type_using_get_with_http_info(group_type, **kwargs)
return data
| 9,049,330,839,815,990,000
|
Get Entity Groups by entity type (getEntityGroupsByType) # noqa: E501
Fetch the list of Entity Group Info objects based on the provided Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_entity_groups_by_type_using_get(group_type, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str group_type: Entity Group type (required)
:return: list[EntityGroupInfo]
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_entity_groups_by_type_using_get
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_entity_groups_by_type_using_get(self, group_type, **kwargs):
"Get Entity Groups by entity type (getEntityGroupsByType) # noqa: E501\n\n Fetch the list of Entity Group Info objects based on the provided Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_groups_by_type_using_get(group_type, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str group_type: Entity Group type (required)\n :return: list[EntityGroupInfo]\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_entity_groups_by_type_using_get_with_http_info(group_type, **kwargs)
else:
data = self.get_entity_groups_by_type_using_get_with_http_info(group_type, **kwargs)
return data
|
def get_entity_groups_by_type_using_get_with_http_info(self, group_type, **kwargs):
"Get Entity Groups by entity type (getEntityGroupsByType) # noqa: E501\n\n Fetch the list of Entity Group Info objects based on the provided Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_groups_by_type_using_get_with_http_info(group_type, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str group_type: Entity Group type (required)\n :return: list[EntityGroupInfo]\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['group_type']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_entity_groups_by_type_using_get" % key))
params[key] = val
del params['kwargs']
if (('group_type' not in params) or (params['group_type'] is None)):
raise ValueError('Missing the required parameter `group_type` when calling `get_entity_groups_by_type_using_get`')
collection_formats = {}
path_params = {}
if ('group_type' in params):
path_params['groupType'] = params['group_type']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroups/{groupType}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[EntityGroupInfo]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
| -2,800,371,283,109,995,500
|
Get Entity Groups by entity type (getEntityGroupsByType) # noqa: E501
Fetch the list of Entity Group Info objects based on the provided Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_entity_groups_by_type_using_get_with_http_info(group_type, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str group_type: Entity Group type (required)
:return: list[EntityGroupInfo]
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_entity_groups_by_type_using_get_with_http_info
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_entity_groups_by_type_using_get_with_http_info(self, group_type, **kwargs):
"Get Entity Groups by entity type (getEntityGroupsByType) # noqa: E501\n\n Fetch the list of Entity Group Info objects based on the provided Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_groups_by_type_using_get_with_http_info(group_type, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str group_type: Entity Group type (required)\n :return: list[EntityGroupInfo]\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['group_type']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_entity_groups_by_type_using_get" % key))
params[key] = val
del params['kwargs']
if (('group_type' not in params) or (params['group_type'] is None)):
raise ValueError('Missing the required parameter `group_type` when calling `get_entity_groups_by_type_using_get`')
collection_formats = {}
path_params = {}
if ('group_type' in params):
path_params['groupType'] = params['group_type']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroups/{groupType}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[EntityGroupInfo]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
|
def get_entity_groups_for_entity_using_get(self, entity_type, entity_id, **kwargs):
"Get Entity Groups by Entity Id (getEntityGroupsForEntity) # noqa: E501\n\n Returns a list of groups that contain the specified Entity Id. For example, all device groups that contain specific device. The list always contain at least one element - special group 'All'.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_groups_for_entity_using_get(entity_type, entity_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_type: Entity Group type (required)\n :param str entity_id: A string value representing the entity id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: list[EntityGroupId]\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_entity_groups_for_entity_using_get_with_http_info(entity_type, entity_id, **kwargs)
else:
data = self.get_entity_groups_for_entity_using_get_with_http_info(entity_type, entity_id, **kwargs)
return data
| -7,510,722,725,745,826,000
|
Get Entity Groups by Entity Id (getEntityGroupsForEntity) # noqa: E501
Returns a list of groups that contain the specified Entity Id. For example, all device groups that contain specific device. The list always contain at least one element - special group 'All'.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_entity_groups_for_entity_using_get(entity_type, entity_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_type: Entity Group type (required)
:param str entity_id: A string value representing the entity id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:return: list[EntityGroupId]
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_entity_groups_for_entity_using_get
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_entity_groups_for_entity_using_get(self, entity_type, entity_id, **kwargs):
"Get Entity Groups by Entity Id (getEntityGroupsForEntity) # noqa: E501\n\n Returns a list of groups that contain the specified Entity Id. For example, all device groups that contain specific device. The list always contain at least one element - special group 'All'.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_groups_for_entity_using_get(entity_type, entity_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_type: Entity Group type (required)\n :param str entity_id: A string value representing the entity id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: list[EntityGroupId]\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_entity_groups_for_entity_using_get_with_http_info(entity_type, entity_id, **kwargs)
else:
data = self.get_entity_groups_for_entity_using_get_with_http_info(entity_type, entity_id, **kwargs)
return data
|
def get_entity_groups_for_entity_using_get_with_http_info(self, entity_type, entity_id, **kwargs):
"Get Entity Groups by Entity Id (getEntityGroupsForEntity) # noqa: E501\n\n Returns a list of groups that contain the specified Entity Id. For example, all device groups that contain specific device. The list always contain at least one element - special group 'All'.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_groups_for_entity_using_get_with_http_info(entity_type, entity_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_type: Entity Group type (required)\n :param str entity_id: A string value representing the entity id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: list[EntityGroupId]\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_type', 'entity_id']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_entity_groups_for_entity_using_get" % key))
params[key] = val
del params['kwargs']
if (('entity_type' not in params) or (params['entity_type'] is None)):
raise ValueError('Missing the required parameter `entity_type` when calling `get_entity_groups_for_entity_using_get`')
if (('entity_id' not in params) or (params['entity_id'] is None)):
raise ValueError('Missing the required parameter `entity_id` when calling `get_entity_groups_for_entity_using_get`')
collection_formats = {}
path_params = {}
if ('entity_type' in params):
path_params['entityType'] = params['entity_type']
if ('entity_id' in params):
path_params['entityId'] = params['entity_id']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroups/{entityType}/{entityId}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[EntityGroupId]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
| -4,774,721,011,841,435,000
|
Get Entity Groups by Entity Id (getEntityGroupsForEntity) # noqa: E501
Returns a list of groups that contain the specified Entity Id. For example, all device groups that contain specific device. The list always contain at least one element - special group 'All'.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_entity_groups_for_entity_using_get_with_http_info(entity_type, entity_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_type: Entity Group type (required)
:param str entity_id: A string value representing the entity id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:return: list[EntityGroupId]
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_entity_groups_for_entity_using_get_with_http_info
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_entity_groups_for_entity_using_get_with_http_info(self, entity_type, entity_id, **kwargs):
"Get Entity Groups by Entity Id (getEntityGroupsForEntity) # noqa: E501\n\n Returns a list of groups that contain the specified Entity Id. For example, all device groups that contain specific device. The list always contain at least one element - special group 'All'.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_entity_groups_for_entity_using_get_with_http_info(entity_type, entity_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_type: Entity Group type (required)\n :param str entity_id: A string value representing the entity id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: list[EntityGroupId]\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_type', 'entity_id']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_entity_groups_for_entity_using_get" % key))
params[key] = val
del params['kwargs']
if (('entity_type' not in params) or (params['entity_type'] is None)):
raise ValueError('Missing the required parameter `entity_type` when calling `get_entity_groups_for_entity_using_get`')
if (('entity_id' not in params) or (params['entity_id'] is None)):
raise ValueError('Missing the required parameter `entity_id` when calling `get_entity_groups_for_entity_using_get`')
collection_formats = {}
path_params = {}
if ('entity_type' in params):
path_params['entityType'] = params['entity_type']
if ('entity_id' in params):
path_params['entityId'] = params['entity_id']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroups/{entityType}/{entityId}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[EntityGroupId]', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
|
def get_group_entity_using_get(self, entity_group_id, entity_id, **kwargs):
"Get Group Entity (getGroupEntity) # noqa: E501\n\n Fetch the Short Entity View object based on the group and entity id. Short Entity View object contains the entity id and number of fields (attributes, telemetry, etc). List of those fields is configurable and defined in the group configuration. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_group_entity_using_get(entity_group_id, entity_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str entity_id: A string value representing the entity id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: ShortEntityView\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_group_entity_using_get_with_http_info(entity_group_id, entity_id, **kwargs)
else:
data = self.get_group_entity_using_get_with_http_info(entity_group_id, entity_id, **kwargs)
return data
| 7,485,628,825,526,395,000
|
Get Group Entity (getGroupEntity) # noqa: E501
Fetch the Short Entity View object based on the group and entity id. Short Entity View object contains the entity id and number of fields (attributes, telemetry, etc). List of those fields is configurable and defined in the group configuration. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_group_entity_using_get(entity_group_id, entity_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:param str entity_id: A string value representing the entity id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:return: ShortEntityView
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_group_entity_using_get
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_group_entity_using_get(self, entity_group_id, entity_id, **kwargs):
"Get Group Entity (getGroupEntity) # noqa: E501\n\n Fetch the Short Entity View object based on the group and entity id. Short Entity View object contains the entity id and number of fields (attributes, telemetry, etc). List of those fields is configurable and defined in the group configuration. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_group_entity_using_get(entity_group_id, entity_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str entity_id: A string value representing the entity id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: ShortEntityView\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_group_entity_using_get_with_http_info(entity_group_id, entity_id, **kwargs)
else:
data = self.get_group_entity_using_get_with_http_info(entity_group_id, entity_id, **kwargs)
return data
|
def get_group_entity_using_get_with_http_info(self, entity_group_id, entity_id, **kwargs):
"Get Group Entity (getGroupEntity) # noqa: E501\n\n Fetch the Short Entity View object based on the group and entity id. Short Entity View object contains the entity id and number of fields (attributes, telemetry, etc). List of those fields is configurable and defined in the group configuration. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_group_entity_using_get_with_http_info(entity_group_id, entity_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str entity_id: A string value representing the entity id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: ShortEntityView\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_group_id', 'entity_id']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_group_entity_using_get" % key))
params[key] = val
del params['kwargs']
if (('entity_group_id' not in params) or (params['entity_group_id'] is None)):
raise ValueError('Missing the required parameter `entity_group_id` when calling `get_group_entity_using_get`')
if (('entity_id' not in params) or (params['entity_id'] is None)):
raise ValueError('Missing the required parameter `entity_id` when calling `get_group_entity_using_get`')
collection_formats = {}
path_params = {}
if ('entity_group_id' in params):
path_params['entityGroupId'] = params['entity_group_id']
if ('entity_id' in params):
path_params['entityId'] = params['entity_id']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/{entityGroupId}/{entityId}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='ShortEntityView', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
| 554,584,701,647,343,100
|
Get Group Entity (getGroupEntity) # noqa: E501
Fetch the Short Entity View object based on the group and entity id. Short Entity View object contains the entity id and number of fields (attributes, telemetry, etc). List of those fields is configurable and defined in the group configuration. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_group_entity_using_get_with_http_info(entity_group_id, entity_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:param str entity_id: A string value representing the entity id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:return: ShortEntityView
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_group_entity_using_get_with_http_info
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_group_entity_using_get_with_http_info(self, entity_group_id, entity_id, **kwargs):
"Get Group Entity (getGroupEntity) # noqa: E501\n\n Fetch the Short Entity View object based on the group and entity id. Short Entity View object contains the entity id and number of fields (attributes, telemetry, etc). List of those fields is configurable and defined in the group configuration. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_group_entity_using_get_with_http_info(entity_group_id, entity_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str entity_id: A string value representing the entity id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: ShortEntityView\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_group_id', 'entity_id']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_group_entity_using_get" % key))
params[key] = val
del params['kwargs']
if (('entity_group_id' not in params) or (params['entity_group_id'] is None)):
raise ValueError('Missing the required parameter `entity_group_id` when calling `get_group_entity_using_get`')
if (('entity_id' not in params) or (params['entity_id'] is None)):
raise ValueError('Missing the required parameter `entity_id` when calling `get_group_entity_using_get`')
collection_formats = {}
path_params = {}
if ('entity_group_id' in params):
path_params['entityGroupId'] = params['entity_group_id']
if ('entity_id' in params):
path_params['entityId'] = params['entity_id']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/{entityGroupId}/{entityId}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='ShortEntityView', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
|
def get_owners_using_get(self, page_size, page, **kwargs):
"Get Owners (getOwners) # noqa: E501\n\n Provides a rage view of Customers that the current user has READ access to. If the current user is Tenant administrator, the result set also contains the tenant. The call is designed for the UI auto-complete component to show tenant and all possible Customers that the user may select to change the owner of the particular entity or entity group. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_owners_using_get(page_size, page, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param int page_size: Maximum amount of entities in a one page (required)\n :param int page: Sequence number of page starting from 0 (required)\n :param str text_search: The case insensitive 'startsWith' filter based on the entity group name.\n :param str sort_property: Property of entity to sort by\n :param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING)\n :return: PageDataContactBasedobject\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_owners_using_get_with_http_info(page_size, page, **kwargs)
else:
data = self.get_owners_using_get_with_http_info(page_size, page, **kwargs)
return data
| -1,044,059,097,860,040,100
|
Get Owners (getOwners) # noqa: E501
Provides a rage view of Customers that the current user has READ access to. If the current user is Tenant administrator, the result set also contains the tenant. The call is designed for the UI auto-complete component to show tenant and all possible Customers that the user may select to change the owner of the particular entity or entity group. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_owners_using_get(page_size, page, async_req=True)
>>> result = thread.get()
:param async_req bool
:param int page_size: Maximum amount of entities in a one page (required)
:param int page: Sequence number of page starting from 0 (required)
:param str text_search: The case insensitive 'startsWith' filter based on the entity group name.
:param str sort_property: Property of entity to sort by
:param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING)
:return: PageDataContactBasedobject
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_owners_using_get
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_owners_using_get(self, page_size, page, **kwargs):
"Get Owners (getOwners) # noqa: E501\n\n Provides a rage view of Customers that the current user has READ access to. If the current user is Tenant administrator, the result set also contains the tenant. The call is designed for the UI auto-complete component to show tenant and all possible Customers that the user may select to change the owner of the particular entity or entity group. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_owners_using_get(page_size, page, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param int page_size: Maximum amount of entities in a one page (required)\n :param int page: Sequence number of page starting from 0 (required)\n :param str text_search: The case insensitive 'startsWith' filter based on the entity group name.\n :param str sort_property: Property of entity to sort by\n :param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING)\n :return: PageDataContactBasedobject\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_owners_using_get_with_http_info(page_size, page, **kwargs)
else:
data = self.get_owners_using_get_with_http_info(page_size, page, **kwargs)
return data
|
def get_owners_using_get_with_http_info(self, page_size, page, **kwargs):
"Get Owners (getOwners) # noqa: E501\n\n Provides a rage view of Customers that the current user has READ access to. If the current user is Tenant administrator, the result set also contains the tenant. The call is designed for the UI auto-complete component to show tenant and all possible Customers that the user may select to change the owner of the particular entity or entity group. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_owners_using_get_with_http_info(page_size, page, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param int page_size: Maximum amount of entities in a one page (required)\n :param int page: Sequence number of page starting from 0 (required)\n :param str text_search: The case insensitive 'startsWith' filter based on the entity group name.\n :param str sort_property: Property of entity to sort by\n :param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING)\n :return: PageDataContactBasedobject\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['page_size', 'page', 'text_search', 'sort_property', 'sort_order']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_owners_using_get" % key))
params[key] = val
del params['kwargs']
if (('page_size' not in params) or (params['page_size'] is None)):
raise ValueError('Missing the required parameter `page_size` when calling `get_owners_using_get`')
if (('page' not in params) or (params['page'] is None)):
raise ValueError('Missing the required parameter `page` when calling `get_owners_using_get`')
collection_formats = {}
path_params = {}
query_params = []
if ('page_size' in params):
query_params.append(('pageSize', params['page_size']))
if ('page' in params):
query_params.append(('page', params['page']))
if ('text_search' in params):
query_params.append(('textSearch', params['text_search']))
if ('sort_property' in params):
query_params.append(('sortProperty', params['sort_property']))
if ('sort_order' in params):
query_params.append(('sortOrder', params['sort_order']))
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/owners{?page,pageSize,sortOrder,sortProperty,textSearch}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='PageDataContactBasedobject', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
| -3,061,577,421,664,482,300
|
Get Owners (getOwners) # noqa: E501
Provides a rage view of Customers that the current user has READ access to. If the current user is Tenant administrator, the result set also contains the tenant. The call is designed for the UI auto-complete component to show tenant and all possible Customers that the user may select to change the owner of the particular entity or entity group. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_owners_using_get_with_http_info(page_size, page, async_req=True)
>>> result = thread.get()
:param async_req bool
:param int page_size: Maximum amount of entities in a one page (required)
:param int page: Sequence number of page starting from 0 (required)
:param str text_search: The case insensitive 'startsWith' filter based on the entity group name.
:param str sort_property: Property of entity to sort by
:param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING)
:return: PageDataContactBasedobject
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
get_owners_using_get_with_http_info
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def get_owners_using_get_with_http_info(self, page_size, page, **kwargs):
"Get Owners (getOwners) # noqa: E501\n\n Provides a rage view of Customers that the current user has READ access to. If the current user is Tenant administrator, the result set also contains the tenant. The call is designed for the UI auto-complete component to show tenant and all possible Customers that the user may select to change the owner of the particular entity or entity group. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.get_owners_using_get_with_http_info(page_size, page, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param int page_size: Maximum amount of entities in a one page (required)\n :param int page: Sequence number of page starting from 0 (required)\n :param str text_search: The case insensitive 'startsWith' filter based on the entity group name.\n :param str sort_property: Property of entity to sort by\n :param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING)\n :return: PageDataContactBasedobject\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['page_size', 'page', 'text_search', 'sort_property', 'sort_order']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method get_owners_using_get" % key))
params[key] = val
del params['kwargs']
if (('page_size' not in params) or (params['page_size'] is None)):
raise ValueError('Missing the required parameter `page_size` when calling `get_owners_using_get`')
if (('page' not in params) or (params['page'] is None)):
raise ValueError('Missing the required parameter `page` when calling `get_owners_using_get`')
collection_formats = {}
path_params = {}
query_params = []
if ('page_size' in params):
query_params.append(('pageSize', params['page_size']))
if ('page' in params):
query_params.append(('page', params['page']))
if ('text_search' in params):
query_params.append(('textSearch', params['text_search']))
if ('sort_property' in params):
query_params.append(('sortProperty', params['sort_property']))
if ('sort_order' in params):
query_params.append(('sortOrder', params['sort_order']))
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/owners{?page,pageSize,sortOrder,sortProperty,textSearch}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='PageDataContactBasedobject', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
|
def make_entity_group_private_using_post(self, entity_group_id, **kwargs):
"Make Entity Group Private (makeEntityGroupPrivate) # noqa: E501\n\n Make the entity group not available for non authorized users. Every group is private by default. This call is useful to hide the group that was previously made public. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.make_entity_group_private_using_post(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.make_entity_group_private_using_post_with_http_info(entity_group_id, **kwargs)
else:
data = self.make_entity_group_private_using_post_with_http_info(entity_group_id, **kwargs)
return data
| -3,196,585,965,353,168,400
|
Make Entity Group Private (makeEntityGroupPrivate) # noqa: E501
Make the entity group not available for non authorized users. Every group is private by default. This call is useful to hide the group that was previously made public. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.make_entity_group_private_using_post(entity_group_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:return: None
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
make_entity_group_private_using_post
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def make_entity_group_private_using_post(self, entity_group_id, **kwargs):
"Make Entity Group Private (makeEntityGroupPrivate) # noqa: E501\n\n Make the entity group not available for non authorized users. Every group is private by default. This call is useful to hide the group that was previously made public. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.make_entity_group_private_using_post(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.make_entity_group_private_using_post_with_http_info(entity_group_id, **kwargs)
else:
data = self.make_entity_group_private_using_post_with_http_info(entity_group_id, **kwargs)
return data
|
def make_entity_group_private_using_post_with_http_info(self, entity_group_id, **kwargs):
"Make Entity Group Private (makeEntityGroupPrivate) # noqa: E501\n\n Make the entity group not available for non authorized users. Every group is private by default. This call is useful to hide the group that was previously made public. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.make_entity_group_private_using_post_with_http_info(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_group_id']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method make_entity_group_private_using_post" % key))
params[key] = val
del params['kwargs']
if (('entity_group_id' not in params) or (params['entity_group_id'] is None)):
raise ValueError('Missing the required parameter `entity_group_id` when calling `make_entity_group_private_using_post`')
collection_formats = {}
path_params = {}
if ('entity_group_id' in params):
path_params['entityGroupId'] = params['entity_group_id']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/{entityGroupId}/makePrivate', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
| -752,541,636,251,510,300
|
Make Entity Group Private (makeEntityGroupPrivate) # noqa: E501
Make the entity group not available for non authorized users. Every group is private by default. This call is useful to hide the group that was previously made public. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.make_entity_group_private_using_post_with_http_info(entity_group_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:return: None
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
make_entity_group_private_using_post_with_http_info
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def make_entity_group_private_using_post_with_http_info(self, entity_group_id, **kwargs):
"Make Entity Group Private (makeEntityGroupPrivate) # noqa: E501\n\n Make the entity group not available for non authorized users. Every group is private by default. This call is useful to hide the group that was previously made public. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.make_entity_group_private_using_post_with_http_info(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_group_id']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method make_entity_group_private_using_post" % key))
params[key] = val
del params['kwargs']
if (('entity_group_id' not in params) or (params['entity_group_id'] is None)):
raise ValueError('Missing the required parameter `entity_group_id` when calling `make_entity_group_private_using_post`')
collection_formats = {}
path_params = {}
if ('entity_group_id' in params):
path_params['entityGroupId'] = params['entity_group_id']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/{entityGroupId}/makePrivate', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
|
def make_entity_group_public_using_post(self, entity_group_id, **kwargs):
"Make Entity Group Publicly available (makeEntityGroupPublic) # noqa: E501\n\n Make the entity group available for non authorized users. Useful for public dashboards that will be embedded into the public websites. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.make_entity_group_public_using_post(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.make_entity_group_public_using_post_with_http_info(entity_group_id, **kwargs)
else:
data = self.make_entity_group_public_using_post_with_http_info(entity_group_id, **kwargs)
return data
| -7,373,107,173,421,755,000
|
Make Entity Group Publicly available (makeEntityGroupPublic) # noqa: E501
Make the entity group available for non authorized users. Useful for public dashboards that will be embedded into the public websites. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.make_entity_group_public_using_post(entity_group_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:return: None
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
make_entity_group_public_using_post
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def make_entity_group_public_using_post(self, entity_group_id, **kwargs):
"Make Entity Group Publicly available (makeEntityGroupPublic) # noqa: E501\n\n Make the entity group available for non authorized users. Useful for public dashboards that will be embedded into the public websites. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.make_entity_group_public_using_post(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.make_entity_group_public_using_post_with_http_info(entity_group_id, **kwargs)
else:
data = self.make_entity_group_public_using_post_with_http_info(entity_group_id, **kwargs)
return data
|
def make_entity_group_public_using_post_with_http_info(self, entity_group_id, **kwargs):
"Make Entity Group Publicly available (makeEntityGroupPublic) # noqa: E501\n\n Make the entity group available for non authorized users. Useful for public dashboards that will be embedded into the public websites. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.make_entity_group_public_using_post_with_http_info(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_group_id']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method make_entity_group_public_using_post" % key))
params[key] = val
del params['kwargs']
if (('entity_group_id' not in params) or (params['entity_group_id'] is None)):
raise ValueError('Missing the required parameter `entity_group_id` when calling `make_entity_group_public_using_post`')
collection_formats = {}
path_params = {}
if ('entity_group_id' in params):
path_params['entityGroupId'] = params['entity_group_id']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/{entityGroupId}/makePublic', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
| 5,361,500,506,757,267,000
|
Make Entity Group Publicly available (makeEntityGroupPublic) # noqa: E501
Make the entity group available for non authorized users. Useful for public dashboards that will be embedded into the public websites. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.make_entity_group_public_using_post_with_http_info(entity_group_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:return: None
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
make_entity_group_public_using_post_with_http_info
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def make_entity_group_public_using_post_with_http_info(self, entity_group_id, **kwargs):
"Make Entity Group Publicly available (makeEntityGroupPublic) # noqa: E501\n\n Make the entity group available for non authorized users. Useful for public dashboards that will be embedded into the public websites. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.make_entity_group_public_using_post_with_http_info(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_group_id']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method make_entity_group_public_using_post" % key))
params[key] = val
del params['kwargs']
if (('entity_group_id' not in params) or (params['entity_group_id'] is None)):
raise ValueError('Missing the required parameter `entity_group_id` when calling `make_entity_group_public_using_post`')
collection_formats = {}
path_params = {}
if ('entity_group_id' in params):
path_params['entityGroupId'] = params['entity_group_id']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/{entityGroupId}/makePublic', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
|
def remove_entities_from_entity_group_using_post(self, entity_group_id, **kwargs):
"Remove entities from the group (removeEntitiesFromEntityGroup) # noqa: E501\n\n Removes entities from the specified entity group. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'REMOVE_FROM_GROUP' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.remove_entities_from_entity_group_using_post(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param list[str] body:\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.remove_entities_from_entity_group_using_post_with_http_info(entity_group_id, **kwargs)
else:
data = self.remove_entities_from_entity_group_using_post_with_http_info(entity_group_id, **kwargs)
return data
| -6,130,842,621,381,224,000
|
Remove entities from the group (removeEntitiesFromEntityGroup) # noqa: E501
Removes entities from the specified entity group. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'REMOVE_FROM_GROUP' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.remove_entities_from_entity_group_using_post(entity_group_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:param list[str] body:
:return: None
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
remove_entities_from_entity_group_using_post
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def remove_entities_from_entity_group_using_post(self, entity_group_id, **kwargs):
"Remove entities from the group (removeEntitiesFromEntityGroup) # noqa: E501\n\n Removes entities from the specified entity group. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'REMOVE_FROM_GROUP' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.remove_entities_from_entity_group_using_post(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param list[str] body:\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.remove_entities_from_entity_group_using_post_with_http_info(entity_group_id, **kwargs)
else:
data = self.remove_entities_from_entity_group_using_post_with_http_info(entity_group_id, **kwargs)
return data
|
def remove_entities_from_entity_group_using_post_with_http_info(self, entity_group_id, **kwargs):
"Remove entities from the group (removeEntitiesFromEntityGroup) # noqa: E501\n\n Removes entities from the specified entity group. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'REMOVE_FROM_GROUP' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.remove_entities_from_entity_group_using_post_with_http_info(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param list[str] body:\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_group_id', 'body']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method remove_entities_from_entity_group_using_post" % key))
params[key] = val
del params['kwargs']
if (('entity_group_id' not in params) or (params['entity_group_id'] is None)):
raise ValueError('Missing the required parameter `entity_group_id` when calling `remove_entities_from_entity_group_using_post`')
collection_formats = {}
path_params = {}
if ('entity_group_id' in params):
path_params['entityGroupId'] = params['entity_group_id']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if ('body' in params):
body_params = params['body']
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
header_params['Content-Type'] = self.api_client.select_header_content_type(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/{entityGroupId}/deleteEntities', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
| 3,813,058,443,029,844,500
|
Remove entities from the group (removeEntitiesFromEntityGroup) # noqa: E501
Removes entities from the specified entity group. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'REMOVE_FROM_GROUP' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.remove_entities_from_entity_group_using_post_with_http_info(entity_group_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:param list[str] body:
:return: None
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
remove_entities_from_entity_group_using_post_with_http_info
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def remove_entities_from_entity_group_using_post_with_http_info(self, entity_group_id, **kwargs):
"Remove entities from the group (removeEntitiesFromEntityGroup) # noqa: E501\n\n Removes entities from the specified entity group. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'REMOVE_FROM_GROUP' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.remove_entities_from_entity_group_using_post_with_http_info(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param list[str] body:\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_group_id', 'body']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method remove_entities_from_entity_group_using_post" % key))
params[key] = val
del params['kwargs']
if (('entity_group_id' not in params) or (params['entity_group_id'] is None)):
raise ValueError('Missing the required parameter `entity_group_id` when calling `remove_entities_from_entity_group_using_post`')
collection_formats = {}
path_params = {}
if ('entity_group_id' in params):
path_params['entityGroupId'] = params['entity_group_id']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if ('body' in params):
body_params = params['body']
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
header_params['Content-Type'] = self.api_client.select_header_content_type(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/{entityGroupId}/deleteEntities', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
|
def save_entity_group_using_post(self, **kwargs):
"Create Or Update Entity Group (saveEntityGroup) # noqa: E501\n\n Create or update the Entity Group. When creating Entity Group, platform generates Entity Group Id as [time-based UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_1_(date-time_and_MAC_address)). The newly created Entity Group Id will be present in the response. Specify existing Entity Group Id to update the group. Referencing non-existing Entity Group Id will cause 'Not Found' error. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.save_entity_group_using_post(async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param EntityGroup body:\n :return: EntityGroupInfo\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.save_entity_group_using_post_with_http_info(**kwargs)
else:
data = self.save_entity_group_using_post_with_http_info(**kwargs)
return data
| -6,062,494,930,232,194,000
|
Create Or Update Entity Group (saveEntityGroup) # noqa: E501
Create or update the Entity Group. When creating Entity Group, platform generates Entity Group Id as [time-based UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_1_(date-time_and_MAC_address)). The newly created Entity Group Id will be present in the response. Specify existing Entity Group Id to update the group. Referencing non-existing Entity Group Id will cause 'Not Found' error. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.save_entity_group_using_post(async_req=True)
>>> result = thread.get()
:param async_req bool
:param EntityGroup body:
:return: EntityGroupInfo
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
save_entity_group_using_post
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def save_entity_group_using_post(self, **kwargs):
"Create Or Update Entity Group (saveEntityGroup) # noqa: E501\n\n Create or update the Entity Group. When creating Entity Group, platform generates Entity Group Id as [time-based UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_1_(date-time_and_MAC_address)). The newly created Entity Group Id will be present in the response. Specify existing Entity Group Id to update the group. Referencing non-existing Entity Group Id will cause 'Not Found' error. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.save_entity_group_using_post(async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param EntityGroup body:\n :return: EntityGroupInfo\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.save_entity_group_using_post_with_http_info(**kwargs)
else:
data = self.save_entity_group_using_post_with_http_info(**kwargs)
return data
|
def save_entity_group_using_post_with_http_info(self, **kwargs):
"Create Or Update Entity Group (saveEntityGroup) # noqa: E501\n\n Create or update the Entity Group. When creating Entity Group, platform generates Entity Group Id as [time-based UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_1_(date-time_and_MAC_address)). The newly created Entity Group Id will be present in the response. Specify existing Entity Group Id to update the group. Referencing non-existing Entity Group Id will cause 'Not Found' error. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.save_entity_group_using_post_with_http_info(async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param EntityGroup body:\n :return: EntityGroupInfo\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['body']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method save_entity_group_using_post" % key))
params[key] = val
del params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if ('body' in params):
body_params = params['body']
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
header_params['Content-Type'] = self.api_client.select_header_content_type(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='EntityGroupInfo', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
| 8,520,411,918,597,085,000
|
Create Or Update Entity Group (saveEntityGroup) # noqa: E501
Create or update the Entity Group. When creating Entity Group, platform generates Entity Group Id as [time-based UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_1_(date-time_and_MAC_address)). The newly created Entity Group Id will be present in the response. Specify existing Entity Group Id to update the group. Referencing non-existing Entity Group Id will cause 'Not Found' error. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.save_entity_group_using_post_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool
:param EntityGroup body:
:return: EntityGroupInfo
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
save_entity_group_using_post_with_http_info
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def save_entity_group_using_post_with_http_info(self, **kwargs):
"Create Or Update Entity Group (saveEntityGroup) # noqa: E501\n\n Create or update the Entity Group. When creating Entity Group, platform generates Entity Group Id as [time-based UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_1_(date-time_and_MAC_address)). The newly created Entity Group Id will be present in the response. Specify existing Entity Group Id to update the group. Referencing non-existing Entity Group Id will cause 'Not Found' error. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.save_entity_group_using_post_with_http_info(async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param EntityGroup body:\n :return: EntityGroupInfo\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['body']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method save_entity_group_using_post" % key))
params[key] = val
del params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if ('body' in params):
body_params = params['body']
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
header_params['Content-Type'] = self.api_client.select_header_content_type(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='EntityGroupInfo', auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
|
def share_entity_group_to_child_owner_user_group_using_post(self, entity_group_id, user_group_id, role_id, **kwargs):
"Share the Entity Group with User group (shareEntityGroupToChildOwnerUserGroup) # noqa: E501\n\n Share the entity group with specified user group using specified role. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.share_entity_group_to_child_owner_user_group_using_post(entity_group_id, user_group_id, role_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id that you would like to share. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str user_group_id: A string value representing the Entity(User) Group Id that you would like to share with. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str role_id: A string value representing the Role Id that describes set of permissions you would like to share (read, write, etc). For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.share_entity_group_to_child_owner_user_group_using_post_with_http_info(entity_group_id, user_group_id, role_id, **kwargs)
else:
data = self.share_entity_group_to_child_owner_user_group_using_post_with_http_info(entity_group_id, user_group_id, role_id, **kwargs)
return data
| 6,930,260,007,750,326,000
|
Share the Entity Group with User group (shareEntityGroupToChildOwnerUserGroup) # noqa: E501
Share the entity group with specified user group using specified role. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.share_entity_group_to_child_owner_user_group_using_post(entity_group_id, user_group_id, role_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_group_id: A string value representing the Entity Group Id that you would like to share. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:param str user_group_id: A string value representing the Entity(User) Group Id that you would like to share with. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:param str role_id: A string value representing the Role Id that describes set of permissions you would like to share (read, write, etc). For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:return: None
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
share_entity_group_to_child_owner_user_group_using_post
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def share_entity_group_to_child_owner_user_group_using_post(self, entity_group_id, user_group_id, role_id, **kwargs):
"Share the Entity Group with User group (shareEntityGroupToChildOwnerUserGroup) # noqa: E501\n\n Share the entity group with specified user group using specified role. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.share_entity_group_to_child_owner_user_group_using_post(entity_group_id, user_group_id, role_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id that you would like to share. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str user_group_id: A string value representing the Entity(User) Group Id that you would like to share with. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str role_id: A string value representing the Role Id that describes set of permissions you would like to share (read, write, etc). For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.share_entity_group_to_child_owner_user_group_using_post_with_http_info(entity_group_id, user_group_id, role_id, **kwargs)
else:
data = self.share_entity_group_to_child_owner_user_group_using_post_with_http_info(entity_group_id, user_group_id, role_id, **kwargs)
return data
|
def share_entity_group_to_child_owner_user_group_using_post_with_http_info(self, entity_group_id, user_group_id, role_id, **kwargs):
"Share the Entity Group with User group (shareEntityGroupToChildOwnerUserGroup) # noqa: E501\n\n Share the entity group with specified user group using specified role. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.share_entity_group_to_child_owner_user_group_using_post_with_http_info(entity_group_id, user_group_id, role_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id that you would like to share. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str user_group_id: A string value representing the Entity(User) Group Id that you would like to share with. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str role_id: A string value representing the Role Id that describes set of permissions you would like to share (read, write, etc). For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_group_id', 'user_group_id', 'role_id']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method share_entity_group_to_child_owner_user_group_using_post" % key))
params[key] = val
del params['kwargs']
if (('entity_group_id' not in params) or (params['entity_group_id'] is None)):
raise ValueError('Missing the required parameter `entity_group_id` when calling `share_entity_group_to_child_owner_user_group_using_post`')
if (('user_group_id' not in params) or (params['user_group_id'] is None)):
raise ValueError('Missing the required parameter `user_group_id` when calling `share_entity_group_to_child_owner_user_group_using_post`')
if (('role_id' not in params) or (params['role_id'] is None)):
raise ValueError('Missing the required parameter `role_id` when calling `share_entity_group_to_child_owner_user_group_using_post`')
collection_formats = {}
path_params = {}
if ('entity_group_id' in params):
path_params['entityGroupId'] = params['entity_group_id']
if ('user_group_id' in params):
path_params['userGroupId'] = params['user_group_id']
if ('role_id' in params):
path_params['roleId'] = params['role_id']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/{entityGroupId}/{userGroupId}/{roleId}/share', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
| 568,845,265,859,664,200
|
Share the Entity Group with User group (shareEntityGroupToChildOwnerUserGroup) # noqa: E501
Share the entity group with specified user group using specified role. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.share_entity_group_to_child_owner_user_group_using_post_with_http_info(entity_group_id, user_group_id, role_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_group_id: A string value representing the Entity Group Id that you would like to share. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:param str user_group_id: A string value representing the Entity(User) Group Id that you would like to share with. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:param str role_id: A string value representing the Role Id that describes set of permissions you would like to share (read, write, etc). For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:return: None
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
share_entity_group_to_child_owner_user_group_using_post_with_http_info
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def share_entity_group_to_child_owner_user_group_using_post_with_http_info(self, entity_group_id, user_group_id, role_id, **kwargs):
"Share the Entity Group with User group (shareEntityGroupToChildOwnerUserGroup) # noqa: E501\n\n Share the entity group with specified user group using specified role. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.share_entity_group_to_child_owner_user_group_using_post_with_http_info(entity_group_id, user_group_id, role_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id that you would like to share. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str user_group_id: A string value representing the Entity(User) Group Id that you would like to share with. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param str role_id: A string value representing the Role Id that describes set of permissions you would like to share (read, write, etc). For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
all_params = ['entity_group_id', 'user_group_id', 'role_id']
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for (key, val) in six.iteritems(params['kwargs']):
if (key not in all_params):
raise TypeError(("Got an unexpected keyword argument '%s' to method share_entity_group_to_child_owner_user_group_using_post" % key))
params[key] = val
del params['kwargs']
if (('entity_group_id' not in params) or (params['entity_group_id'] is None)):
raise ValueError('Missing the required parameter `entity_group_id` when calling `share_entity_group_to_child_owner_user_group_using_post`')
if (('user_group_id' not in params) or (params['user_group_id'] is None)):
raise ValueError('Missing the required parameter `user_group_id` when calling `share_entity_group_to_child_owner_user_group_using_post`')
if (('role_id' not in params) or (params['role_id'] is None)):
raise ValueError('Missing the required parameter `role_id` when calling `share_entity_group_to_child_owner_user_group_using_post`')
collection_formats = {}
path_params = {}
if ('entity_group_id' in params):
path_params['entityGroupId'] = params['entity_group_id']
if ('user_group_id' in params):
path_params['userGroupId'] = params['user_group_id']
if ('role_id' in params):
path_params['roleId'] = params['role_id']
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
header_params['Accept'] = self.api_client.select_header_accept(['application/json'])
auth_settings = ['X-Authorization']
return self.api_client.call_api('/api/entityGroup/{entityGroupId}/{userGroupId}/{roleId}/share', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
|
def share_entity_group_using_post(self, entity_group_id, **kwargs):
"Share the Entity Group (shareEntityGroup) # noqa: E501\n\n Share the entity group with certain user group based on the provided Share Group Request. The request is quite flexible and processing of the request involves multiple security checks using platform RBAC feature. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.share_entity_group_using_post(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param ShareGroupRequest body:\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.share_entity_group_using_post_with_http_info(entity_group_id, **kwargs)
else:
data = self.share_entity_group_using_post_with_http_info(entity_group_id, **kwargs)
return data
| -6,011,038,966,855,095,000
|
Share the Entity Group (shareEntityGroup) # noqa: E501
Share the entity group with certain user group based on the provided Share Group Request. The request is quite flexible and processing of the request involves multiple security checks using platform RBAC feature. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.share_entity_group_using_post(entity_group_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)
:param ShareGroupRequest body:
:return: None
If the method is called asynchronously,
returns the request thread.
|
tb_rest_client/api/api_pe/entity_group_controller_api.py
|
share_entity_group_using_post
|
D34DPlayer/thingsboard-python-rest-client
|
python
|
def share_entity_group_using_post(self, entity_group_id, **kwargs):
"Share the Entity Group (shareEntityGroup) # noqa: E501\n\n Share the entity group with certain user group based on the provided Share Group Request. The request is quite flexible and processing of the request involves multiple security checks using platform RBAC feature. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501\n This method makes a synchronous HTTP request by default. To make an\n asynchronous HTTP request, please pass async_req=True\n >>> thread = api.share_entity_group_using_post(entity_group_id, async_req=True)\n >>> result = thread.get()\n\n :param async_req bool\n :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required)\n :param ShareGroupRequest body:\n :return: None\n If the method is called asynchronously,\n returns the request thread.\n "
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.share_entity_group_using_post_with_http_info(entity_group_id, **kwargs)
else:
data = self.share_entity_group_using_post_with_http_info(entity_group_id, **kwargs)
return data
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.