Skip to content

dispatch_pb2_grpc

frequenz.api.dispatch.v1.dispatch_pb2_grpc ¤

Client and server classes corresponding to protobuf-defined services.

Classes¤

frequenz.api.dispatch.v1.dispatch_pb2_grpc.MicrogridDispatchService ¤

Bases: object

Service providing operations related to dispatching microgrid components.

Overview¤

The API serves to automate the process of electricity dispatches for microgrids. In the context of the energy industry, a 'dispatch' refers to the act of routing electrical power between different components within a microgrid or between a microgrid and the main grid. This could be for the purpose of supply (sending electricity to the grid or components within the microgrid), or demand (drawing electricity from the grid or from other components like batteries and solar arrays).

Objective¤

The primary objective of this API is to streamline and automate the complex task of electricity dispatching, making it easier to manage local electricity supply and demand efficiently.

Key Features¤
  • Dispatching Electricity: Comprehensive CRUD operations for dispatching microgrid components.
  • Automation: Support for one-time as well as recurring dispatches based on flexible recurrence rules.
  • Fine-grained control: Dispatch individual microgrid components or entire component categories.
Example Use Cases¤
  • Charging or discharging a battery based on optimal time-of-use rates.
  • Limiting the output of a Photovoltaic (PV) array during periods of low demand.
  • Invoking Frequency Containment Reserves (FCR) or Automatic Frequency Restoration Reserves (aFRR) to support grid operations.
  • Adjusting the output of electric vehicle charging stations to match grid availability or to avoid peak pricing.
Target Audience¤

This API is designed for application developers in the energy sector who focus on the tasks of optimizing microgrid electricity flows. Its design aims to be as developer-friendly as possible, requiring no prior knowledge in electrical engineering and systems.

Security¤

ALL requests to this service must be signed. The key and signature should be added to the request metadata (HTTP headers). The signature should be computed using the HMAC-SHA256 algorithm and the user's secret key.

ALL requests to this service must be made over HTTPS.

Source code in frequenz/api/dispatch/v1/dispatch_pb2_grpc.py 
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
class MicrogridDispatchService(object):
    """Service providing operations related to dispatching microgrid components.

    #### Overview

    The API serves to automate the process of electricity dispatches for microgrids.
    In the context of the energy industry, a 'dispatch' refers to the act of routing electrical power
    between different components within a microgrid or between a microgrid and the main grid.
    This could be for the purpose of supply (sending electricity to the grid or components within the microgrid),
    or demand (drawing electricity from the grid or from other components like batteries and solar arrays).

    #### Objective

    The primary objective of this API is to streamline and automate the complex task of electricity dispatching,
    making it easier to manage local electricity supply and demand efficiently.

    #### Key Features

    - Dispatching Electricity: Comprehensive CRUD operations for dispatching microgrid components.
    - Automation: Support for one-time as well as recurring dispatches based on flexible recurrence rules.
    - Fine-grained control: Dispatch individual microgrid components or entire component categories.

    #### Example Use Cases

    - Charging or discharging a battery based on optimal time-of-use rates.
    - Limiting the output of a Photovoltaic (PV) array during periods of low demand.
    - Invoking Frequency Containment Reserves (FCR) or Automatic Frequency Restoration Reserves (aFRR) to
    support grid operations.
    - Adjusting the output of electric vehicle charging stations to match grid availability or to avoid peak pricing.

    #### Target Audience

    This API is designed for application developers in the energy sector who focus on the tasks of optimizing microgrid
    electricity flows. Its design aims to be as developer-friendly as possible, requiring no prior knowledge in
    electrical engineering and systems.

    #### Security

    ALL requests to this service must be signed. The key and signature
    should be added to the request metadata (HTTP headers). The signature
    should be computed using the HMAC-SHA256 algorithm and the user's secret key.

    ALL requests to this service must be made over HTTPS.
    """

    @staticmethod
    def ListMicrogridDispatches(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/frequenz.api.dispatch.v1.MicrogridDispatchService/ListMicrogridDispatches',
            frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.ListMicrogridDispatchesRequest.SerializeToString,
            frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.ListMicrogridDispatchesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StreamMicrogridDispatches(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/frequenz.api.dispatch.v1.MicrogridDispatchService/StreamMicrogridDispatches',
            frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.StreamMicrogridDispatchesRequest.SerializeToString,
            frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.StreamMicrogridDispatchesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateMicrogridDispatch(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/frequenz.api.dispatch.v1.MicrogridDispatchService/CreateMicrogridDispatch',
            frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.CreateMicrogridDispatchRequest.SerializeToString,
            frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.CreateMicrogridDispatchResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateMicrogridDispatch(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/frequenz.api.dispatch.v1.MicrogridDispatchService/UpdateMicrogridDispatch',
            frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.UpdateMicrogridDispatchRequest.SerializeToString,
            frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.UpdateMicrogridDispatchResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMicrogridDispatch(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/frequenz.api.dispatch.v1.MicrogridDispatchService/GetMicrogridDispatch',
            frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.GetMicrogridDispatchRequest.SerializeToString,
            frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.GetMicrogridDispatchResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteMicrogridDispatch(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/frequenz.api.dispatch.v1.MicrogridDispatchService/DeleteMicrogridDispatch',
            frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.DeleteMicrogridDispatchRequest.SerializeToString,
            frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.DeleteMicrogridDispatchResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

frequenz.api.dispatch.v1.dispatch_pb2_grpc.MicrogridDispatchServiceAsyncStub ¤

Service providing operations related to dispatching microgrid components.

Overview¤

The API serves to automate the process of electricity dispatches for microgrids. In the context of the energy industry, a 'dispatch' refers to the act of routing electrical power between different components within a microgrid or between a microgrid and the main grid. This could be for the purpose of supply (sending electricity to the grid or components within the microgrid), or demand (drawing electricity from the grid or from other components like batteries and solar arrays).

Objective¤

The primary objective of this API is to streamline and automate the complex task of electricity dispatching, making it easier to manage local electricity supply and demand efficiently.

Key Features¤
  • Dispatching Electricity: Comprehensive CRUD operations for dispatching microgrid components.
  • Automation: Support for one-time as well as recurring dispatches based on flexible recurrence rules.
  • Fine-grained control: Dispatch individual microgrid components or entire component categories.
Example Use Cases¤
  • Charging or discharging a battery based on optimal time-of-use rates.
  • Limiting the output of a Photovoltaic (PV) array during periods of low demand.
  • Invoking Frequency Containment Reserves (FCR) or Automatic Frequency Restoration Reserves (aFRR) to support grid operations.
  • Adjusting the output of electric vehicle charging stations to match grid availability or to avoid peak pricing.
Target Audience¤

This API is designed for application developers in the energy sector who focus on the tasks of optimizing microgrid electricity flows. Its design aims to be as developer-friendly as possible, requiring no prior knowledge in electrical engineering and systems.

Security¤

ALL requests to this service must be signed. The key and signature should be added to the request metadata (HTTP headers). The signature should be computed using the HMAC-SHA256 algorithm and the user's secret key.

ALL requests to this service must be made over HTTPS.

Source code in frequenz/api/dispatch/v1/dispatch_pb2_grpc.py 
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
        self.DeleteMicrogridDispatch = channel.unary_unary(
                '/frequenz.api.dispatch.v1.MicrogridDispatchService/DeleteMicrogridDispatch',
                request_serializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.DeleteMicrogridDispatchRequest.SerializeToString,
                response_deserializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.DeleteMicrogridDispatchResponse.FromString,
                _registered_method=True)


class MicrogridDispatchServiceServicer(object):
    """Service providing operations related to dispatching microgrid components.

    #### Overview

    The API serves to automate the process of electricity dispatches for microgrids.
    In the context of the energy industry, a 'dispatch' refers to the act of routing electrical power
    between different components within a microgrid or between a microgrid and the main grid.
    This could be for the purpose of supply (sending electricity to the grid or components within the microgrid),
    or demand (drawing electricity from the grid or from other components like batteries and solar arrays).

    #### Objective

    The primary objective of this API is to streamline and automate the complex task of electricity dispatching,
    making it easier to manage local electricity supply and demand efficiently.

    #### Key Features

    - Dispatching Electricity: Comprehensive CRUD operations for dispatching microgrid components.
    - Automation: Support for one-time as well as recurring dispatches based on flexible recurrence rules.
    - Fine-grained control: Dispatch individual microgrid components or entire component categories.

    #### Example Use Cases

    - Charging or discharging a battery based on optimal time-of-use rates.
    - Limiting the output of a Photovoltaic (PV) array during periods of low demand.
    - Invoking Frequency Containment Reserves (FCR) or Automatic Frequency Restoration Reserves (aFRR) to
    support grid operations.
    - Adjusting the output of electric vehicle charging stations to match grid availability or to avoid peak pricing.

    #### Target Audience

    This API is designed for application developers in the energy sector who focus on the tasks of optimizing microgrid
    electricity flows. Its design aims to be as developer-friendly as possible, requiring no prior knowledge in
    electrical engineering and systems.

    #### Security

    ALL requests to this service must be signed. The key and signature
    should be added to the request metadata (HTTP headers). The signature
    should be computed using the HMAC-SHA256 algorithm and the user's secret key.

    ALL requests to this service must be made over HTTPS.
    """

    def ListMicrogridDispatches(self, request, context):
        """Returns a list of all dispatches
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StreamMicrogridDispatches(self, request, context):
        """Streaming RPC for receiving dispatch updates for a given microgrid
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateMicrogridDispatch(self, request, context):
        """Create a new dispatch
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UpdateMicrogridDispatch(self, request, context):
        """Update a dispatch
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')
Attributes¤
CreateMicrogridDispatch instance-attribute ¤
CreateMicrogridDispatch: UnaryUnaryMultiCallable[
    CreateMicrogridDispatchRequest,
    CreateMicrogridDispatchResponse,
]

Create a new dispatch

DeleteMicrogridDispatch instance-attribute ¤
DeleteMicrogridDispatch: UnaryUnaryMultiCallable[
    DeleteMicrogridDispatchRequest,
    DeleteMicrogridDispatchResponse,
]

Delete a given dispatch

GetMicrogridDispatch instance-attribute ¤
GetMicrogridDispatch: UnaryUnaryMultiCallable[
    GetMicrogridDispatchRequest,
    GetMicrogridDispatchResponse,
]

Get a single dispatch

ListMicrogridDispatches instance-attribute ¤
ListMicrogridDispatches: UnaryUnaryMultiCallable[
    ListMicrogridDispatchesRequest,
    ListMicrogridDispatchesResponse,
]

Returns a list of all dispatches

StreamMicrogridDispatches instance-attribute ¤
StreamMicrogridDispatches: UnaryStreamMultiCallable[
    StreamMicrogridDispatchesRequest,
    StreamMicrogridDispatchesResponse,
]

Streaming RPC for receiving dispatch updates for a given microgrid

UpdateMicrogridDispatch instance-attribute ¤
UpdateMicrogridDispatch: UnaryUnaryMultiCallable[
    UpdateMicrogridDispatchRequest,
    UpdateMicrogridDispatchResponse,
]

Update a dispatch

frequenz.api.dispatch.v1.dispatch_pb2_grpc.MicrogridDispatchServiceServicer ¤

Bases: object

Service providing operations related to dispatching microgrid components.

Overview¤

The API serves to automate the process of electricity dispatches for microgrids. In the context of the energy industry, a 'dispatch' refers to the act of routing electrical power between different components within a microgrid or between a microgrid and the main grid. This could be for the purpose of supply (sending electricity to the grid or components within the microgrid), or demand (drawing electricity from the grid or from other components like batteries and solar arrays).

Objective¤

The primary objective of this API is to streamline and automate the complex task of electricity dispatching, making it easier to manage local electricity supply and demand efficiently.

Key Features¤
  • Dispatching Electricity: Comprehensive CRUD operations for dispatching microgrid components.
  • Automation: Support for one-time as well as recurring dispatches based on flexible recurrence rules.
  • Fine-grained control: Dispatch individual microgrid components or entire component categories.
Example Use Cases¤
  • Charging or discharging a battery based on optimal time-of-use rates.
  • Limiting the output of a Photovoltaic (PV) array during periods of low demand.
  • Invoking Frequency Containment Reserves (FCR) or Automatic Frequency Restoration Reserves (aFRR) to support grid operations.
  • Adjusting the output of electric vehicle charging stations to match grid availability or to avoid peak pricing.
Target Audience¤

This API is designed for application developers in the energy sector who focus on the tasks of optimizing microgrid electricity flows. Its design aims to be as developer-friendly as possible, requiring no prior knowledge in electrical engineering and systems.

Security¤

ALL requests to this service must be signed. The key and signature should be added to the request metadata (HTTP headers). The signature should be computed using the HMAC-SHA256 algorithm and the user's secret key.

ALL requests to this service must be made over HTTPS.

Source code in frequenz/api/dispatch/v1/dispatch_pb2_grpc.py 
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
class MicrogridDispatchServiceServicer(object):
    """Service providing operations related to dispatching microgrid components.

    #### Overview

    The API serves to automate the process of electricity dispatches for microgrids.
    In the context of the energy industry, a 'dispatch' refers to the act of routing electrical power
    between different components within a microgrid or between a microgrid and the main grid.
    This could be for the purpose of supply (sending electricity to the grid or components within the microgrid),
    or demand (drawing electricity from the grid or from other components like batteries and solar arrays).

    #### Objective

    The primary objective of this API is to streamline and automate the complex task of electricity dispatching,
    making it easier to manage local electricity supply and demand efficiently.

    #### Key Features

    - Dispatching Electricity: Comprehensive CRUD operations for dispatching microgrid components.
    - Automation: Support for one-time as well as recurring dispatches based on flexible recurrence rules.
    - Fine-grained control: Dispatch individual microgrid components or entire component categories.

    #### Example Use Cases

    - Charging or discharging a battery based on optimal time-of-use rates.
    - Limiting the output of a Photovoltaic (PV) array during periods of low demand.
    - Invoking Frequency Containment Reserves (FCR) or Automatic Frequency Restoration Reserves (aFRR) to
    support grid operations.
    - Adjusting the output of electric vehicle charging stations to match grid availability or to avoid peak pricing.

    #### Target Audience

    This API is designed for application developers in the energy sector who focus on the tasks of optimizing microgrid
    electricity flows. Its design aims to be as developer-friendly as possible, requiring no prior knowledge in
    electrical engineering and systems.

    #### Security

    ALL requests to this service must be signed. The key and signature
    should be added to the request metadata (HTTP headers). The signature
    should be computed using the HMAC-SHA256 algorithm and the user's secret key.

    ALL requests to this service must be made over HTTPS.
    """

    def ListMicrogridDispatches(self, request, context):
        """Returns a list of all dispatches
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StreamMicrogridDispatches(self, request, context):
        """Streaming RPC for receiving dispatch updates for a given microgrid
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateMicrogridDispatch(self, request, context):
        """Create a new dispatch
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UpdateMicrogridDispatch(self, request, context):
        """Update a dispatch
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetMicrogridDispatch(self, request, context):
        """Get a single dispatch
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeleteMicrogridDispatch(self, request, context):
        """Delete a given dispatch
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')
Functions¤
CreateMicrogridDispatch ¤
CreateMicrogridDispatch(
    request: CreateMicrogridDispatchRequest,
    context: _ServicerContext,
) -> Union[
    CreateMicrogridDispatchResponse,
    Awaitable[CreateMicrogridDispatchResponse],
]

Create a new dispatch

Source code in frequenz/api/dispatch/v1/dispatch_pb2_grpc.py 
175
176
177
178
179
180
def CreateMicrogridDispatch(self, request, context):
    """Create a new dispatch
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')
DeleteMicrogridDispatch ¤
DeleteMicrogridDispatch(
    request: DeleteMicrogridDispatchRequest,
    context: _ServicerContext,
) -> Union[
    DeleteMicrogridDispatchResponse,
    Awaitable[DeleteMicrogridDispatchResponse],
]

Delete a given dispatch

Source code in frequenz/api/dispatch/v1/dispatch_pb2_grpc.py 
196
197
198
199
200
201
def DeleteMicrogridDispatch(self, request, context):
    """Delete a given dispatch
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')
GetMicrogridDispatch ¤
GetMicrogridDispatch(
    request: GetMicrogridDispatchRequest,
    context: _ServicerContext,
) -> Union[
    GetMicrogridDispatchResponse,
    Awaitable[GetMicrogridDispatchResponse],
]

Get a single dispatch

Source code in frequenz/api/dispatch/v1/dispatch_pb2_grpc.py 
189
190
191
192
193
194
def GetMicrogridDispatch(self, request, context):
    """Get a single dispatch
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')
ListMicrogridDispatches ¤
ListMicrogridDispatches(
    request: ListMicrogridDispatchesRequest,
    context: _ServicerContext,
) -> Union[
    ListMicrogridDispatchesResponse,
    Awaitable[ListMicrogridDispatchesResponse],
]

Returns a list of all dispatches

Source code in frequenz/api/dispatch/v1/dispatch_pb2_grpc.py 
161
162
163
164
165
166
def ListMicrogridDispatches(self, request, context):
    """Returns a list of all dispatches
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')
StreamMicrogridDispatches ¤
StreamMicrogridDispatches(
    request: StreamMicrogridDispatchesRequest,
    context: _ServicerContext,
) -> Union[
    Iterator[StreamMicrogridDispatchesResponse],
    AsyncIterator[StreamMicrogridDispatchesResponse],
]

Streaming RPC for receiving dispatch updates for a given microgrid

Source code in frequenz/api/dispatch/v1/dispatch_pb2_grpc.py 
168
169
170
171
172
173
def StreamMicrogridDispatches(self, request, context):
    """Streaming RPC for receiving dispatch updates for a given microgrid
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')
UpdateMicrogridDispatch ¤
UpdateMicrogridDispatch(
    request: UpdateMicrogridDispatchRequest,
    context: _ServicerContext,
) -> Union[
    UpdateMicrogridDispatchResponse,
    Awaitable[UpdateMicrogridDispatchResponse],
]

Update a dispatch

Source code in frequenz/api/dispatch/v1/dispatch_pb2_grpc.py 
182
183
184
185
186
187
def UpdateMicrogridDispatch(self, request, context):
    """Update a dispatch
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!')

frequenz.api.dispatch.v1.dispatch_pb2_grpc.MicrogridDispatchServiceStub ¤

Bases: object

Service providing operations related to dispatching microgrid components.

Overview¤

The API serves to automate the process of electricity dispatches for microgrids. In the context of the energy industry, a 'dispatch' refers to the act of routing electrical power between different components within a microgrid or between a microgrid and the main grid. This could be for the purpose of supply (sending electricity to the grid or components within the microgrid), or demand (drawing electricity from the grid or from other components like batteries and solar arrays).

Objective¤

The primary objective of this API is to streamline and automate the complex task of electricity dispatching, making it easier to manage local electricity supply and demand efficiently.

Key Features¤
  • Dispatching Electricity: Comprehensive CRUD operations for dispatching microgrid components.
  • Automation: Support for one-time as well as recurring dispatches based on flexible recurrence rules.
  • Fine-grained control: Dispatch individual microgrid components or entire component categories.
Example Use Cases¤
  • Charging or discharging a battery based on optimal time-of-use rates.
  • Limiting the output of a Photovoltaic (PV) array during periods of low demand.
  • Invoking Frequency Containment Reserves (FCR) or Automatic Frequency Restoration Reserves (aFRR) to support grid operations.
  • Adjusting the output of electric vehicle charging stations to match grid availability or to avoid peak pricing.
Target Audience¤

This API is designed for application developers in the energy sector who focus on the tasks of optimizing microgrid electricity flows. Its design aims to be as developer-friendly as possible, requiring no prior knowledge in electrical engineering and systems.

Security¤

ALL requests to this service must be signed. The key and signature should be added to the request metadata (HTTP headers). The signature should be computed using the HMAC-SHA256 algorithm and the user's secret key.

ALL requests to this service must be made over HTTPS.

Source code in frequenz/api/dispatch/v1/dispatch_pb2_grpc.py 
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
class MicrogridDispatchServiceStub(object):
    """Service providing operations related to dispatching microgrid components.

    #### Overview

    The API serves to automate the process of electricity dispatches for microgrids.
    In the context of the energy industry, a 'dispatch' refers to the act of routing electrical power
    between different components within a microgrid or between a microgrid and the main grid.
    This could be for the purpose of supply (sending electricity to the grid or components within the microgrid),
    or demand (drawing electricity from the grid or from other components like batteries and solar arrays).

    #### Objective

    The primary objective of this API is to streamline and automate the complex task of electricity dispatching,
    making it easier to manage local electricity supply and demand efficiently.

    #### Key Features

    - Dispatching Electricity: Comprehensive CRUD operations for dispatching microgrid components.
    - Automation: Support for one-time as well as recurring dispatches based on flexible recurrence rules.
    - Fine-grained control: Dispatch individual microgrid components or entire component categories.

    #### Example Use Cases

    - Charging or discharging a battery based on optimal time-of-use rates.
    - Limiting the output of a Photovoltaic (PV) array during periods of low demand.
    - Invoking Frequency Containment Reserves (FCR) or Automatic Frequency Restoration Reserves (aFRR) to
    support grid operations.
    - Adjusting the output of electric vehicle charging stations to match grid availability or to avoid peak pricing.

    #### Target Audience

    This API is designed for application developers in the energy sector who focus on the tasks of optimizing microgrid
    electricity flows. Its design aims to be as developer-friendly as possible, requiring no prior knowledge in
    electrical engineering and systems.

    #### Security

    ALL requests to this service must be signed. The key and signature
    should be added to the request metadata (HTTP headers). The signature
    should be computed using the HMAC-SHA256 algorithm and the user's secret key.

    ALL requests to this service must be made over HTTPS.
    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.ListMicrogridDispatches = channel.unary_unary(
                '/frequenz.api.dispatch.v1.MicrogridDispatchService/ListMicrogridDispatches',
                request_serializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.ListMicrogridDispatchesRequest.SerializeToString,
                response_deserializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.ListMicrogridDispatchesResponse.FromString,
                _registered_method=True)
        self.StreamMicrogridDispatches = channel.unary_stream(
                '/frequenz.api.dispatch.v1.MicrogridDispatchService/StreamMicrogridDispatches',
                request_serializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.StreamMicrogridDispatchesRequest.SerializeToString,
                response_deserializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.StreamMicrogridDispatchesResponse.FromString,
                _registered_method=True)
        self.CreateMicrogridDispatch = channel.unary_unary(
                '/frequenz.api.dispatch.v1.MicrogridDispatchService/CreateMicrogridDispatch',
                request_serializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.CreateMicrogridDispatchRequest.SerializeToString,
                response_deserializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.CreateMicrogridDispatchResponse.FromString,
                _registered_method=True)
        self.UpdateMicrogridDispatch = channel.unary_unary(
                '/frequenz.api.dispatch.v1.MicrogridDispatchService/UpdateMicrogridDispatch',
                request_serializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.UpdateMicrogridDispatchRequest.SerializeToString,
                response_deserializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.UpdateMicrogridDispatchResponse.FromString,
                _registered_method=True)
        self.GetMicrogridDispatch = channel.unary_unary(
                '/frequenz.api.dispatch.v1.MicrogridDispatchService/GetMicrogridDispatch',
                request_serializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.GetMicrogridDispatchRequest.SerializeToString,
                response_deserializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.GetMicrogridDispatchResponse.FromString,
                _registered_method=True)
        self.DeleteMicrogridDispatch = channel.unary_unary(
                '/frequenz.api.dispatch.v1.MicrogridDispatchService/DeleteMicrogridDispatch',
                request_serializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.DeleteMicrogridDispatchRequest.SerializeToString,
                response_deserializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.DeleteMicrogridDispatchResponse.FromString,
                _registered_method=True)
Attributes¤
CreateMicrogridDispatch instance-attribute ¤
CreateMicrogridDispatch: UnaryUnaryMultiCallable[
    CreateMicrogridDispatchRequest,
    CreateMicrogridDispatchResponse,
] = unary_unary(
    "/frequenz.api.dispatch.v1.MicrogridDispatchService/CreateMicrogridDispatch",
    request_serializer=SerializeToString,
    response_deserializer=FromString,
    _registered_method=True,
)

Create a new dispatch

DeleteMicrogridDispatch instance-attribute ¤
DeleteMicrogridDispatch: UnaryUnaryMultiCallable[
    DeleteMicrogridDispatchRequest,
    DeleteMicrogridDispatchResponse,
] = unary_unary(
    "/frequenz.api.dispatch.v1.MicrogridDispatchService/DeleteMicrogridDispatch",
    request_serializer=SerializeToString,
    response_deserializer=FromString,
    _registered_method=True,
)

Delete a given dispatch

GetMicrogridDispatch instance-attribute ¤
GetMicrogridDispatch: UnaryUnaryMultiCallable[
    GetMicrogridDispatchRequest,
    GetMicrogridDispatchResponse,
] = unary_unary(
    "/frequenz.api.dispatch.v1.MicrogridDispatchService/GetMicrogridDispatch",
    request_serializer=SerializeToString,
    response_deserializer=FromString,
    _registered_method=True,
)

Get a single dispatch

ListMicrogridDispatches instance-attribute ¤
ListMicrogridDispatches: UnaryUnaryMultiCallable[
    ListMicrogridDispatchesRequest,
    ListMicrogridDispatchesResponse,
] = unary_unary(
    "/frequenz.api.dispatch.v1.MicrogridDispatchService/ListMicrogridDispatches",
    request_serializer=SerializeToString,
    response_deserializer=FromString,
    _registered_method=True,
)

Returns a list of all dispatches

StreamMicrogridDispatches instance-attribute ¤
StreamMicrogridDispatches: UnaryStreamMultiCallable[
    StreamMicrogridDispatchesRequest,
    StreamMicrogridDispatchesResponse,
] = unary_stream(
    "/frequenz.api.dispatch.v1.MicrogridDispatchService/StreamMicrogridDispatches",
    request_serializer=SerializeToString,
    response_deserializer=FromString,
    _registered_method=True,
)

Streaming RPC for receiving dispatch updates for a given microgrid

UpdateMicrogridDispatch instance-attribute ¤
UpdateMicrogridDispatch: UnaryUnaryMultiCallable[
    UpdateMicrogridDispatchRequest,
    UpdateMicrogridDispatchResponse,
] = unary_unary(
    "/frequenz.api.dispatch.v1.MicrogridDispatchService/UpdateMicrogridDispatch",
    request_serializer=SerializeToString,
    response_deserializer=FromString,
    _registered_method=True,
)

Update a dispatch

Functions¤
__init__ ¤
__init__(channel: Union[Channel, Channel]) -> None

Constructor.

PARAMETER DESCRIPTION
channel

A grpc.Channel.

TYPE: Union[Channel, Channel]

Source code in frequenz/api/dispatch/v1/dispatch_pb2_grpc.py 
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
def __init__(self, channel):
    """Constructor.

    Args:
        channel: A grpc.Channel.
    """
    self.ListMicrogridDispatches = channel.unary_unary(
            '/frequenz.api.dispatch.v1.MicrogridDispatchService/ListMicrogridDispatches',
            request_serializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.ListMicrogridDispatchesRequest.SerializeToString,
            response_deserializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.ListMicrogridDispatchesResponse.FromString,
            _registered_method=True)
    self.StreamMicrogridDispatches = channel.unary_stream(
            '/frequenz.api.dispatch.v1.MicrogridDispatchService/StreamMicrogridDispatches',
            request_serializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.StreamMicrogridDispatchesRequest.SerializeToString,
            response_deserializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.StreamMicrogridDispatchesResponse.FromString,
            _registered_method=True)
    self.CreateMicrogridDispatch = channel.unary_unary(
            '/frequenz.api.dispatch.v1.MicrogridDispatchService/CreateMicrogridDispatch',
            request_serializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.CreateMicrogridDispatchRequest.SerializeToString,
            response_deserializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.CreateMicrogridDispatchResponse.FromString,
            _registered_method=True)
    self.UpdateMicrogridDispatch = channel.unary_unary(
            '/frequenz.api.dispatch.v1.MicrogridDispatchService/UpdateMicrogridDispatch',
            request_serializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.UpdateMicrogridDispatchRequest.SerializeToString,
            response_deserializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.UpdateMicrogridDispatchResponse.FromString,
            _registered_method=True)
    self.GetMicrogridDispatch = channel.unary_unary(
            '/frequenz.api.dispatch.v1.MicrogridDispatchService/GetMicrogridDispatch',
            request_serializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.GetMicrogridDispatchRequest.SerializeToString,
            response_deserializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.GetMicrogridDispatchResponse.FromString,
            _registered_method=True)
    self.DeleteMicrogridDispatch = channel.unary_unary(
            '/frequenz.api.dispatch.v1.MicrogridDispatchService/DeleteMicrogridDispatch',
            request_serializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.DeleteMicrogridDispatchRequest.SerializeToString,
            response_deserializer=frequenz_dot_api_dot_dispatch_dot_v1_dot_dispatch__pb2.DeleteMicrogridDispatchResponse.FromString,
            _registered_method=True)