add an example request (with answers)

Signed-off-by: EstherLerouzic <esther.lerouzic@orange.com>
Change-Id: Id75fff88cd3b03fcf965c22763075ac3dbea41c6

.docker-entry.sh

@@ -1,3 +1,3 @@
 #!/bin/bash
-cp -nr /oopt-gnpy/gnpy/example-data /shared
+cp -nr /opt/application/oopt-gnpy/gnpy/example-data /shared
 exec "$@"

Dockerfile

@@ -1,8 +1,15 @@
 FROM python:3.7-slim
-COPY . /oopt-gnpy
-WORKDIR /oopt-gnpy
-RUN apt update; apt install -y git
-RUN pip install .
-WORKDIR /shared/example-data
-ENTRYPOINT ["/oopt-gnpy/.docker-entry.sh"]
+WORKDIR /opt/application/oopt-gnpy
+RUN mkdir -p /shared/example-data \
+    && groupadd gnpy \
+    && useradd -g gnpy -m gnpy \
+    && apt-get update \
+    && apt-get install git -y \
+    && rm -rf /var/lib/apt/lists/*
+COPY . /opt/application/oopt-gnpy
+WORKDIR /opt/application/oopt-gnpy
+RUN pip install . \
+    && chown -Rc gnpy:gnpy /opt/application/oopt-gnpy /shared/example-data
+USER gnpy
+ENTRYPOINT ["/opt/application/oopt-gnpy/.docker-entry.sh"]
 CMD ["/bin/bash"]

README.rst

@@ -128,6 +128,25 @@ As a result transponder type is not part of the network info. it is related to t
 
 The current version includes a spectrum assigment features that enables to compute a candidate spectrum assignment for each service based on a first fit policy. Spectrum is assigned based on service specified spacing value, path_bandwidth value and selected mode for the transceiver. This spectrum assignment includes a basic capacity planning capability so that the spectrum resource is limited by the frequency min and max values defined for the links. If the requested services reach the link spectrum capacity, additional services feasibility are computed but marked as blocked due to spectrum reason.
 
+REST API (experimental)
+-----------------------
+``gnpy`` provides an experimental api for requesting several paths at once. It is based on Flask server.
+You can run it through command line or Docker.
+
+.. code-block:: shell-session
+
+     $ gnpy-rest
+
+.. code-block:: shell-session
+
+    $ docker run -p 8080:8080 -dit xxxx gnpy-rest
+
+After starting the api server, you can lauch a request
+
+.. code-block:: shell-session
+
+    $ curl -v -X POST -H "Content-Type: application/json" -d @<PATH_TO_JSON_REQUEST_FILE> http://localhost:8080/api/v1/path-computation
+
 
 Contributing
 ------------

gnpy/example-data/meshTopologyExampleV2_services.json

@@ -14,8 +14,8 @@
           "trx_mode": null,
           "effective-freq-slot": [
             {
-              "N": "null",
-              "M": "null"
+              "N": null,
+              "M": null
             }
           ],
           "spacing": 50000000000.0,
@@ -39,8 +39,8 @@
           "trx_mode": "mode 1",
           "effective-freq-slot": [
             {
-              "N": "null",
-              "M": "null"
+              "N": null,
+              "M": null
             }
           ],
           "spacing": 50000000000.0,
@@ -104,8 +104,8 @@
           "trx_mode": "mode 1",
           "effective-freq-slot": [
             {
-              "N": "null",
-              "M": "null"
+              "N": null,
+              "M": null
             }
           ],
           "spacing": 50000000000.0,
@@ -129,8 +129,8 @@
           "trx_mode": null,
           "effective-freq-slot": [
             {
-              "N": "null",
-              "M": "null"
+              "N": null,
+              "M": null
             }
           ],
           "spacing": 75000000000.0,
@@ -154,8 +154,8 @@
           "trx_mode": "mode 2",
           "effective-freq-slot": [
             {
-              "N": "null",
-              "M": "null"
+              "N": null,
+              "M": null
             }
           ],
           "spacing": 75000000000.0,
@@ -179,8 +179,8 @@
           "trx_mode": "mode 1",
           "effective-freq-slot": [
             {
-              "N": "null",
-              "M": "null"
+              "N": null,
+              "M": null
             }
           ],
           "spacing": 50000000000.0,
@@ -204,8 +204,8 @@
           "trx_mode": "mode 1",
           "effective-freq-slot": [
             {
-              "N": "null",
-              "M": "null"
+              "N": null,
+              "M": null
             }
           ],
           "spacing": 50000000000.0,
@@ -229,8 +229,8 @@
           "trx_mode": "mode 1",
           "effective-freq-slot": [
             {
-              "N": "null",
-              "M": "null"
+              "N": null,
+              "M": null
             }
           ],
           "spacing": 75000000000.0,

gnpy/tools/cli_examples.py

@@ -188,6 +188,7 @@ def transmission_main_example(args=None):
     params['loose_list'] = ['strict']
     params['format'] = ''
     params['path_bandwidth'] = 0
+    params['effective_freq_slot'] = None
     trx_params = trx_mode_params(equipment)
     if args.power:
         trx_params['power'] = db2lin(float(args.power)) * 1e-3

gnpy/tools/json_io.py

@@ -431,7 +431,10 @@ def requests_from_json(json_data, equipment):
         params['bidir'] = req['bidirectional']
         params['destination'] = req['destination']
         params['trx_type'] = req['path-constraints']['te-bandwidth']['trx_type']
-        params['trx_mode'] = req['path-constraints']['te-bandwidth']['trx_mode']
+        if 'trx_mode' in req['path-constraints']['te-bandwidth'].keys():
+            params['trx_mode'] = req['path-constraints']['te-bandwidth']['trx_mode']
+        else:
+            params['trx_mode'] = None
         params['format'] = params['trx_mode']
         params['spacing'] = req['path-constraints']['te-bandwidth']['spacing']
         try:
@@ -466,6 +469,11 @@ def requests_from_json(json_data, equipment):
                 params['nb_channel'] = automatic_nch(f_min, f_max_from_si, params['spacing'])
         except KeyError:
             params['nb_channel'] = automatic_nch(f_min, f_max_from_si, params['spacing'])
+        if 'effective-freq-slot' in req['path-constraints']['te-bandwidth']:
+            # temporarily reads only the first slot
+            params['effective_freq_slot'] = req['path-constraints']['te-bandwidth']['effective-freq-slot'][0]
+        else:
+            params['effective_freq_slot'] = None
         _check_one_request(params, f_max_from_si)
 
         try:

gnpy/tools/rest_example.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+'''
+gnpy.tools.rest_example
+=======================
+
+GNPy as a rest API example
+'''
+
+import json
+import logging
+import os
+import re
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+
+import werkzeug
+from flask import Flask, request
+from numpy import mean
+from werkzeug.exceptions import InternalServerError
+
+import gnpy.core.ansi_escapes as ansi_escapes
+import gnpy.core.exceptions as exceptions
+from gnpy.core.network import build_network
+from gnpy.core.utils import lin2db, automatic_nch
+from gnpy.tools.json_io import requests_from_json, disjunctions_from_json, _equipment_from_json, network_from_json
+from gnpy.topology.request import (ResultElement, compute_path_dsjctn, requests_aggregation,
+                                   correct_json_route_list,
+                                   deduplicate_disjunctions, compute_path_with_disjunction)
+from gnpy.topology.spectrum_assignment import build_oms_list, pth_assign_spectrum
+
+_logger = logging.getLogger(__name__)
+_examples_dir = Path(__file__).parent.parent / 'example-data'
+_reaesc = re.compile(r'\x1b[^m]*m')
+app = Flask(__name__)
+
+
+@app.route('/api/v1/path-computation', methods=['POST'])
+def compute_path():
+    data = request.json
+    service = data['gnpy-api:service']
+    topology = data['gnpy-api:topology']
+    equipment = _equipment_from_json(data['gnpy-api:equipment'],
+                                     os.path.join(_examples_dir, 'std_medium_gain_advanced_config.json'))
+    network = network_from_json(topology, equipment)
+
+    propagatedpths, reversed_propagatedpths, rqs = path_requests_run(service, network, equipment)
+    # Generate the output
+    result = []
+    # assumes that list of rqs and list of propgatedpths have same order
+    for i, pth in enumerate(propagatedpths):
+        result.append(ResultElement(rqs[i], pth, reversed_propagatedpths[i]))
+    return {"result": {"response": [n.json for n in result]}}, 201
+
+
+@app.route('/api/v1/status', methods=['GET'])
+def api_status():
+    return {"version": "v1", "status": "ok"}, 200
+
+
+def _init_logger():
+    handler = RotatingFileHandler('api.log', maxBytes=1024 * 1024, backupCount=5, encoding='utf-8')
+    ch = logging.StreamHandler()
+    logging.basicConfig(level=logging.INFO, handlers=[handler, ch],
+                        format="%(asctime)s %(levelname)s %(name)s(%(lineno)s) [%(threadName)s - %(thread)d] - %("
+                               "message)s")
+
+
+def path_requests_run(service, network, equipment):
+    # Build the network once using the default power defined in SI in eqpt config
+    # TODO power density: db2linp(ower_dbm": 0)/power_dbm": 0 * nb channels as defined by
+    # spacing, f_min and f_max
+    p_db = equipment['SI']['default'].power_dbm
+
+    p_total_db = p_db + lin2db(automatic_nch(equipment['SI']['default'].f_min,
+                                             equipment['SI']['default'].f_max, equipment['SI']['default'].spacing))
+    build_network(network, equipment, p_db, p_total_db)
+    oms_list = build_oms_list(network, equipment)
+    rqs = requests_from_json(service, equipment)
+
+    # check that request ids are unique. Non unique ids, may
+    # mess the computation: better to stop the computation
+    all_ids = [r.request_id for r in rqs]
+    if len(all_ids) != len(set(all_ids)):
+        for item in list(set(all_ids)):
+            all_ids.remove(item)
+        msg = f'Requests id {all_ids} are not unique'
+        _logger.critical(msg)
+        raise ValueError('Requests id ' + all_ids + ' are not unique')
+    rqs = correct_json_route_list(network, rqs)
+
+    # pths = compute_path(network, equipment, rqs)
+    dsjn = disjunctions_from_json(service)
+
+    # need to warn or correct in case of wrong disjunction form
+    # disjunction must not be repeated with same or different ids
+    dsjn = deduplicate_disjunctions(dsjn)
+
+    rqs, dsjn = requests_aggregation(rqs, dsjn)
+    # TODO export novel set of aggregated demands in a json file
+
+    _logger.info(f'{ansi_escapes.blue}The following services have been requested:{ansi_escapes.reset}' + str(rqs))
+
+    _logger.info(f'{ansi_escapes.blue}Computing all paths with constraints{ansi_escapes.reset}')
+    pths = compute_path_dsjctn(network, equipment, rqs, dsjn)
+
+    _logger.info(f'{ansi_escapes.blue}Propagating on selected path{ansi_escapes.reset}')
+    propagatedpths, reversed_pths, reversed_propagatedpths = compute_path_with_disjunction(network, equipment, rqs,
+                                                                                           pths)
+    # Note that deepcopy used in compute_path_with_disjunction returns
+    # a list of nodes which are not belonging to network (they are copies of the node objects).
+    # so there can not be propagation on these nodes.
+
+    pth_assign_spectrum(pths, rqs, oms_list, reversed_pths)
+    return propagatedpths, reversed_propagatedpths, rqs
+
+
+def common_error_handler(exception):
+    """
+
+    :type exception: Exception
+
+    """
+    status_code = 500
+    if not isinstance(exception, werkzeug.exceptions.HTTPException):
+        exception = werkzeug.exceptions.InternalServerError()
+        exception.description = "Something went wrong on our side."
+
+    response = {
+        'message': exception.name,
+        'description': exception.description,
+        'code': exception.code
+    }
+
+    return werkzeug.Response(response=json.dumps(response), status=status_code, mimetype='application/json')
+
+
+def bad_request_handler(exception):
+    response = {
+        'message': 'bad request',
+        'description': _reaesc.sub('', str(exception)),
+        'code': 400
+    }
+    return werkzeug.Response(response=json.dumps(response), status=400, mimetype='application/json')
+
+
+def _init_app():
+    app.register_error_handler(KeyError, bad_request_handler)
+    app.register_error_handler(TypeError, bad_request_handler)
+    app.register_error_handler(ValueError, bad_request_handler)
+    app.register_error_handler(exceptions.ConfigurationError, bad_request_handler)
+    app.register_error_handler(exceptions.DisjunctionError, bad_request_handler)
+    app.register_error_handler(exceptions.EquipmentConfigError, bad_request_handler)
+    app.register_error_handler(exceptions.NetworkTopologyError, bad_request_handler)
+    app.register_error_handler(exceptions.ServiceError, bad_request_handler)
+    app.register_error_handler(exceptions.SpectrumError, bad_request_handler)
+    app.register_error_handler(exceptions.ParametersError, bad_request_handler)
+    app.register_error_handler(AssertionError, bad_request_handler)
+    app.register_error_handler(InternalServerError, common_error_handler)
+    for error_code in werkzeug.exceptions.default_exceptions:
+        app.register_error_handler(error_code, common_error_handler)
+
+
+def main():
+    _init_logger()
+    _init_app()
+    app.run(host='0.0.0.0', port=8080)
+
+
+if __name__ == '__main__':
+    main()

gnpy/tools/service_sheet.py

@@ -127,7 +127,7 @@ class Request_element(Element):
                     'technology': 'flexi-grid',
                     'trx_type': self.trx_type,
                     'trx_mode': self.mode,
-                    'effective-freq-slot': [{'N': 'null', 'M': 'null'}],
+                    'effective-freq-slot': [{'N': None, 'M': None}],
                     'spacing': self.spacing,
                     'max-nb-of-channel': self.nb_channel,
                     'output-power': self.power

gnpy/topology/request.py

@@ -35,7 +35,7 @@ LOGGER = getLogger(__name__)
 RequestParams = namedtuple('RequestParams', 'request_id source destination bidir trx_type' +
                            ' trx_mode nodes_list loose_list spacing power nb_channel f_min' +
                            ' f_max format baud_rate OSNR bit_rate roll_off tx_osnr' +
-                           ' min_spacing cost path_bandwidth')
+                           ' min_spacing cost path_bandwidth effective_freq_slot')
 DisjunctionParams = namedtuple('DisjunctionParams', 'disjunction_id relaxable link' +
                                '_diverse node_diverse disjunctions_req')
 
@@ -68,6 +68,9 @@ class PathRequest:
         self.min_spacing = params.min_spacing
         self.cost = params.cost
         self.path_bandwidth = params.path_bandwidth
+        if params.effective_freq_slot is not None:
+            self.N = params.effective_freq_slot['N']
+            self.M = params.effective_freq_slot['M']
 
     def __str__(self):
         return '\n\t'.join([f'{type(self).__name__} {self.request_id}',
@@ -387,7 +390,6 @@ def propagate_and_optimize_mode(path, req, equipment):
                 else:
                     req.blocking_reason = 'NO_COMPUTED_SNR'
                     return path, None
-
         # only get to this point if no baudrate/mode satisfies OSNR requirement
 
         # returns the last propagated path and mode
@@ -1151,7 +1153,8 @@ def compute_path_with_disjunction(network, equipment, pathreqlist, pathlist):
                     print(msg)
                     LOGGER.warning(msg)
                     # TODO selection of mode should also be on reversed direction !!
-                    pathreq.blocking_reason = 'MODE_NOT_FEASIBLE'
+                    if not hasattr(pathreq, 'blocking_reason'):
+                        pathreq.blocking_reason = 'MODE_NOT_FEASIBLE'
             else:
                 propagated_reversed_path = []
         else:

gnpy/topology/spectrum_assignment.py

@@ -395,7 +395,7 @@ def pth_assign_spectrum(pths, rqs, oms_list, rpths):
         try:
             if rqs[i].blocking_reason:
                 rqs[i].blocked = True
-                rqs[i].N = 0
+                rqs[i].N = None
                 rqs[i].M = 0
         except AttributeError:
             nb_wl = ceil(rqs[i].path_bandwidth / rqs[i].bit_rate)
@@ -404,9 +404,25 @@ def pth_assign_spectrum(pths, rqs, oms_list, rpths):
             # assumes that all channels must be grouped
             # TODO : enables non contiguous reservation in case of blocking
             requested_m = ceil(rqs[i].spacing / 0.0125e12) * nb_wl
-            # concatenate all path and reversed path elements to derive slots availability
+            if hasattr(rqs[i], 'M') and rqs[i].M is not None:
+                # Consistency check between the requested M and path_bandwidth
+                # M value should be bigger than the computed requested_m (simple estimate)
+                # TODO: elaborate a more accurate estimate with nb_wl * tx_osnr + possibly guardbands in case of
+                # superchannel closed packing.
+                if  requested_m <= rqs[i].M:
+                    requested_m = rqs[i].M
+                else:
+                    # TODO : create a specific blocking reason and following process for this case instead of an exception
+                    raise SpectrumError(f'requested M {rqs[i].M} number of slots for request {rqs[i].request_id} ' +
+                                        f'should be greater than {requested_m} to support request ' +
+                                        f'{rqs[i].path_bandwidth * 1e-9} Gbit/s with {rqs[i].tsp} {rqs[i].tsp_mode}')
+            # else: there is no M value so the programs uses the requested_m one
+            if hasattr(rqs[i], 'N'):
+                requested_n = rqs[i].N
+            else:
+                requested_n = None
             (center_n, startn, stopn), path_oms = spectrum_selection(pth + rpths[i], oms_list, requested_m,
-                                                                     requested_n=None)
+                                                                     requested_n)
             # checks that requested_m is fitting startm and stopm
             # if not None, center_n and start, stop frequencies are applicable to all oms of pth
             # checks that spectrum is not None else indicate blocking reason
@@ -426,6 +442,6 @@ def pth_assign_spectrum(pths, rqs, oms_list, rpths):
                 rqs[i].M = requested_m
             else:
                 rqs[i].blocked = True
-                rqs[i].N = 0
+                rqs[i].N = None
                 rqs[i].M = 0
                 rqs[i].blocking_reason = 'NO_SPECTRUM'

gnpy/yang/gnpy-api@2020-10-22.yang

@@ -0,0 +1,53 @@
+module gnpy-api {
+  yang-version 1.1;
+  namespace "gnpy:gnpy-api";
+  prefix gnpyapi;
+
+  import gnpy-network-topology {
+    prefix gnpynt;
+  }
+  import gnpy-path-computation-simplified {
+    prefix gnpypc;
+  }
+  import gnpy-eqpt-config {
+    prefix gnpyeqpt;
+  }
+
+  organization
+    "Telecom Infra Project OOPT PSE Working Group";
+  contact
+    "WG Web:   <https://github.com/Telecominfraproject/oopt-gnpy>
+     contact:  <mailto:ahmed.triki@orange.com>
+     contact:  <mailto:esther.lerouzic@orange.com>
+    ";
+  description
+    "YANG model for gnpy api input for path computation - TransportPCE preversion";
+
+  revision 2020-10-22 {
+    description
+      "draft for experimental/2020-candi";
+    reference
+      "YANG model for api input for path computation with gnpy";
+  }
+
+    container service {
+      description
+        "Describe the service file to connect to gnpy";
+      uses gnpypc:service;
+    }
+    container result {
+     uses gnpypc:result;
+     description
+     "Describe the response object to gnpy";
+    }
+    container topology {
+      description
+        "Describe the topology file to connect to gnpy";
+      uses gnpynt:topo;
+    }
+    container equipment {
+      description
+        "Describe the equipment library to connect to gnpy";
+      uses gnpyeqpt:eqpt;
+    }
+}

gnpy/yang/gnpy-eqpt-config@2020-10-22.yang

@@ -0,0 +1,442 @@
+module gnpy-eqpt-config {
+  yang-version 1;
+  namespace "gnpy:gnpy-eqpt-config";
+
+  prefix "gnpyeqpt";
+
+  organization
+    "Telecom Infra Project OOPT PSE
+     Working Group";
+
+  contact
+    "WG Web:   <https://github.com/Telecominfraproject/oopt-gnpy>
+     contact:  <mailto:ahmed.triki@orange.com>
+     contact:  <mailto:esther.lerouzic@orange.com>
+   ";
+
+  description "Base YANG model for gnpy equipment library input for path computation - 2020 - candi preversion";
+
+  revision "2020-10-22" {
+    description "draft for experimental/2020-candi";
+    reference "Base YANG model for equipment library input for path computation with gnpy";
+  }
+
+  /*
+   * Identities
+
+
+  identity edfa-type-def {
+    description "base identity for variable gain and fixed gain";
+  }
+
+  identity variable-gain{
+    base edfa-type-def ;
+    description "'variable_gain' is a simplified model simulating a 2-coil 
+      EDFA with internal, input and output VOAs. The NF vs gain response is calculated 
+      accordingly based on the input parameters: nf_min, nf_max, and gain_flatmax. It 
+      is not a simple interpolation but a 2-stage NF calculation.";
+  }
+
+  identity fixed-gain{
+    base edfa-type-def ;
+    description "'fixed_gain' is a fixed gain model. NF == Cte == nf0 if gain_min < gain < gain_flatmax";
+  }
+
+  identity fiber-variety {
+    description "base identity for fiber variety";
+  }
+
+  identity transceiver-variety {
+    description "base identity for transceiver variety";
+  }
+
+  */
+  grouping variable-gain {
+    leaf nf_min {
+      type decimal64 {
+        fraction-digits 2;
+      }
+      units dB;
+    }
+    leaf nf_max {
+      type decimal64 {
+        fraction-digits 2;
+      }
+      units dB;
+    }
+    leaf out_voa_auto{
+      type boolean ;
+      description "auto_design feature to optimize the amplifier output VOA. If true, output VOA is present 
+      and will be used to push amplifier gain to its maximum, within EOL power margins.";
+    }
+  }
+
+  grouping fixed-gain{
+    leaf nf0 {
+      type decimal64 {
+        fraction-digits 2;
+      }
+      units dB;
+    }
+  }
+
+  grouping no-type-def{
+    leaf advanced_config_from_json {
+      type string ;
+      description " filename with json edfa";
+      
+    }
+  }
+  
+
+  grouping openroadm{
+    leaf-list nf_coef {
+      type decimal64 {
+        fraction-digits 5;
+      }
+      //default [8.1e-4,6.142e-2,1.558,19.97] ;
+    }
+  }
+
+  grouping dual-stage {
+    leaf raman {
+      type boolean;
+    }
+    leaf preamp_variety {
+      type leafref {
+          path "../../Edfa/type_variety";
+        }
+    }
+    leaf booster_variety {
+      type leafref {
+          path "../../Edfa/type_variety";
+        }
+    }
+  }
+
+  grouping edfa-common {
+    leaf allowed_for_design{
+      type boolean ;
+      description "If false, the amplifier will not be picked by auto-design but it can still be used as a 
+      manual input (from JSON or Excel template topology files.)";
+    }
+    leaf gain_flatmax {
+      type decimal64 {
+        fraction-digits 2;
+      }
+      units dB;
+    }
+    leaf gain_min {
+      type decimal64 {
+        fraction-digits 2;
+      }
+      units dB;
+    }
+    leaf p_max {
+      type decimal64 {
+        fraction-digits 2;
+      }
+      units dBm;
+    }
+    leaf type_def {
+      type identityref{
+        base edfa-type-def ;
+      }
+    }
+    choice type_of_model {
+      case variable-gain {
+        when "type_def = 'variable-gain'";
+        uses variable-gain ;
+      }
+      case fixed-gain{
+        when "type_def = 'fixed-gain'";
+        uses fixed-gain;
+      }
+      case no-type-def{
+        when "type_def = 'no-type-def'";
+        uses no-type-def;
+      }
+      case openroadm{
+        when "type_def = 'openroadm'";
+        uses openroadm;
+      }
+      case dual_stage {
+        when "type_def = 'dual_stage'";
+        uses dual-stage ;
+      }
+    }
+  }
+
+  grouping common-fiber {
+    description "common parameters for fiber and raman fiber";
+    leaf type_variety {
+      type string ;
+      }
+      description "a unique name to ID the fiber in the JSON or Excel template topology input file";
+    leaf dispersion{
+      type decimal64 {
+        fraction-digits 8;
+      }
+      units s.m-1.m-1;
+    }
+    leaf gamma{
+      type decimal64 {
+        fraction-digits 8;
+      }
+      units w-1.m-1 ;
+      description "2pi.n2/(lambda*Aeff) (w-2.m-1)";
+    }
+    leaf pmd_coef{
+      type decimal64 {
+        fraction-digits 16;
+      }
+      units s.sqrt(m)-1;
+    }      
+  }
+
+  grouping eqpt{
+    list Edfa {
+      key type_variety;
+      leaf type_variety {
+        type string;
+        description "a unique name to ID the amplifier in the JSON/Excel template topology input file";
+      }
+      uses edfa-common;
+    }
+
+    list Fiber {
+      key type_variety;
+      uses common-fiber;
+    }
+
+    list RamanFiber {
+      uses common-fiber;
+      container raman_efficiency {
+        leaf-list cr {
+          type decimal64 {
+            fraction-digits 8;
+          }
+        }
+        leaf-list frequency_offset {
+          type decimal64 {
+            fraction-digits 8;
+          }
+        }
+      }
+    }
+
+    list Span {
+      leaf power_mode {
+        type boolean ;
+      }
+      leaf-list delta_power_range_db {
+        type decimal64 {
+          fraction-digits 2;
+        }
+      }
+      leaf max_length {
+        type decimal64 {
+          fraction-digits 2;
+        }
+        units km;
+        default 150.0 ;
+      }
+      leaf max_loss {
+        type decimal64 {
+          fraction-digits 2;
+        }
+        units dB;
+      }
+      leaf max_fiber_lineic_loss_for_raman {
+        type decimal64 {
+          fraction-digits 2;
+        }
+        units dB.km-1;      
+      }
+      leaf target_extended_gain {
+        type decimal64 {
+          fraction-digits 2;
+        }
+        units dB;
+      }
+      leaf length_units{
+        type string ;
+        default "km";
+      }
+      leaf padding{
+        type decimal64 {
+          fraction-digits 2;
+        }
+        default 10.0 ;
+      }
+      leaf EOL{
+         type decimal64 {
+          fraction-digits 2;
+        }
+        default 0.0 ;
+      }
+      leaf con_in{
+        type decimal64 {
+          fraction-digits 2;
+        }
+        default 0.0 ;
+      }
+      leaf con_out{
+        type decimal64 {
+          fraction-digits 2;
+        }    
+        default 0.0 ;
+      }
+    }
+
+    list Roadm {
+      leaf target_pch_out_db {
+        type decimal64 {
+          fraction-digits 2;
+        }
+      }
+      leaf add_drop_osnr {
+        type decimal64 {
+          fraction-digits 2;
+        }
+      }
+      leaf pmd {
+        type decimal64 {
+          fraction-digits 2;
+        }
+      }
+      container restrictions {
+        leaf-list preamp_variety_list {
+          type string;
+        }
+        leaf-list booster_variety_list {
+          type string;
+        }
+      }
+    }
+
+    list SI {
+      leaf f_min {
+        type decimal64 {
+          fraction-digits 2;
+        }
+      }
+      leaf f_max {
+        type decimal64 {
+          fraction-digits 2;
+        }
+      }
+      leaf baud_rate {
+        type decimal64 {
+          fraction-digits 2;
+        }
+      }
+      leaf spacing {
+        type decimal64 {
+          fraction-digits 2;
+        }
+      }
+      leaf power_dbm {
+        type decimal64 {
+          fraction-digits 2;
+        }
+      }
+      leaf-list power_range_db {
+        type decimal64 {
+          fraction-digits 2;
+        }
+      }
+      leaf roll_off {
+        type decimal64 {
+          fraction-digits 2;
+        }
+      }
+      leaf tx_osnr {
+        type decimal64 {
+          fraction-digits 2;
+        }
+      }
+      leaf sys_margins {
+        type decimal64 {
+          fraction-digits 2;
+        }
+      }
+    }
+
+    list Transceiver {
+      leaf type_variety {
+        type string ;
+        description "a unique name to ID the transceiver in the JSON or Excel template topology input file";
+      }
+      container frequency {
+        leaf min {
+          type decimal64 {
+              fraction-digits 2;
+            }
+          units Hz ;
+        }
+        leaf max {
+          type decimal64 {
+              fraction-digits 2;
+            }
+          units Hz ;
+        }
+        description "Min/max frequency of transponder eg 191.35e12  and 196.1e12";
+      }
+      list mode {
+        leaf format {
+          type string ;
+          description "unique name of the mode";
+        }
+        leaf baud_rate {
+          type decimal64 {
+              fraction-digits 2;
+            }
+          units baud ;
+          description "baud_rate";
+        }
+        leaf OSNR {
+          type decimal64 {
+              fraction-digits 2;
+            }
+          units dB ;
+          description "min required OSNR in 0.1nm (dB)";
+        }
+        leaf tx_osnr {
+          type decimal64 {
+              fraction-digits 2;
+            }
+          units dB ;
+          description "min required OSNR in 0.1nm (dB)";
+        }
+        leaf min_spacing {
+          type decimal64 {
+              fraction-digits 2;
+            }
+          units GHz ;
+          description "...";
+        }    
+        leaf bit_rate {
+          type decimal64 {
+              fraction-digits 2;
+            }
+          units bit/s ;
+          description "bit rate";
+        }
+        leaf roll_off {
+          type decimal64 {
+              fraction-digits 2;
+            }
+          description "...";
+        }
+        leaf cost {
+          type decimal64 {
+              fraction-digits 2;
+            }
+          description "arbitrary unit";
+        }
+      }
+    }
+  }
+}
+

gnpy/yang/gnpy-network-topology@2020-10-22.yang

@@ -0,0 +1,300 @@
+module gnpy-network-topology {
+  yang-version 1.1;
+  namespace "gnpy:gnpy-network-topology";
+  prefix gnpynt;
+
+  organization
+    "Telecom Infra Project OOPT PSE Working Group";
+  contact
+    "WG Web:   <https://github.com/Telecominfraproject/oopt-gnpy>
+     contact:  <mailto:ahmed.triki@orange.com>
+     contact:  <mailto:esther.lerouzic@orange.com>
+    ";
+  description
+    "YANG model for gnpy network input for path computation - 2020 - candi preversion";
+
+  revision 2020-10-22 {
+    description
+      "draft for experimental/2020-candi";
+    reference
+      "YANG model for network input for path computation with gnpy";
+  }
+
+  identity type-element {
+    description
+      "Base identity for element type";
+  }
+
+  identity Transceiver {
+    base type-element;
+    description
+      " Transceiver element";
+  }
+
+  identity Fiber {
+    base type-element;
+    description
+      "Fiber element (unidirectional)";
+  }
+
+  identity Roadm {
+    base type-element;
+    description
+      "Roadm element";
+  }
+
+  identity Edfa {
+    base type-element;
+    description
+      "Edfa element";
+  }
+
+  identity Fused {
+    base type-element;
+    description
+      "Fused element ; non amplified connection between two fiber spans ;
+       can be used to model optical distribution frame, or losses due to
+       connectors or fused in a span";
+  }
+
+  identity length-unit {
+    description
+      "length unit";
+  }
+
+  identity km {
+    base length-unit;
+    description
+      "kilometers";
+  }
+
+  identity m {
+    base length-unit;
+    description
+      "meter";
+  }
+
+  typedef Coordinate {
+    type decimal64 {
+      fraction-digits 6;
+    }
+  }
+
+  typedef Coef {
+    type decimal64 {
+      fraction-digits 2;
+    }
+  }
+
+  grouping location-attributes {
+    container location {
+      leaf city {
+        type string;
+        mandatory true;
+      }
+      leaf region {
+        type string;
+        mandatory true;
+      }
+      leaf latitude {
+        type Coordinate;
+        mandatory true;
+      }
+      leaf longitude {
+        type Coordinate;
+        mandatory true;
+      }
+    }
+  }
+
+  grouping fiber-params {
+    description
+      ".....";
+    leaf length {
+      type decimal64 {
+        fraction-digits 2;
+      }
+      mandatory true;
+    }
+    leaf loss_coef {
+      type decimal64 {
+        fraction-digits 2;
+      }
+      mandatory true;
+      units db/km;
+      description "Loss coefficient of the fiber span (dB/km)";
+    }
+    leaf length_units {
+      type identityref {
+        base length-unit;
+      }
+      mandatory true;
+    }
+    leaf att_in {
+      type decimal64 {
+        fraction-digits 2;
+      }
+      units "dB";
+      mandatory true;
+    }
+    leaf con_in {
+      type decimal64 {
+        fraction-digits 2;
+      }
+      units "dB";
+      mandatory true;
+    }
+    leaf con_out {
+      type decimal64 {
+        fraction-digits 2;
+      }
+      units "dB";
+      mandatory true;
+    }
+  }
+
+  grouping edfa-params {
+    container operational {
+      description
+        "Operational values for the Edfa ";
+      leaf gain_target {
+        type decimal64 {
+          fraction-digits 2;
+        }
+        units "dB";
+        mandatory true;
+        description
+          "gain target of the amplifier (before VOA and after att_in)";
+      }
+      leaf tilt_target {
+        type decimal64 {
+          fraction-digits 2;
+        }
+        mandatory true;
+        description
+          "..";
+      }
+      leaf out_voa {
+        type decimal64 {
+          fraction-digits 2;
+        }
+        units "dB";
+        mandatory true;
+        description
+          "..";
+      }
+      leaf delta_p {
+        type decimal64 {
+          fraction-digits 2;
+        }
+        units "dB";
+        mandatory true;
+        description
+          "per channel target output power delta with respect to power setting in SI";
+      }
+    }
+  }
+
+  grouping roadm-params {
+    leaf target_pch_out_db {
+      type decimal64 {
+        fraction-digits 2;
+      }
+      units "dB";
+      description
+        "..";
+    }
+    container restrictions {
+      leaf-list preamp_variety_list {
+        type string;
+        description 
+          "List of authorized preamp type-variety";
+      }
+      leaf-list booster_variety_list {
+        type string;
+        description 
+          "List of authorized booster type-variety";
+      }
+    }
+  }
+
+  grouping transceiver-params;
+
+  grouping fused-params{
+    leaf loss {
+      type decimal64 {
+        fraction-digits 2;
+      }
+      units "dB";
+      description
+        "Concentrated loss of the fused element";    
+    }
+  }
+
+  grouping element-type-choice {
+    choice element-type {
+      case Edfa {
+        when "type = 'Edfa'";
+        uses edfa-params;
+      }
+      case FiberRoadm {
+        container params {
+          choice fiberroadmfused {
+            case Fiber {
+              when "type = 'Fiber'";
+              uses fiber-params;
+            }
+            case Roadm {
+              when "type = 'Roadm'";
+              uses roadm-params;
+            }
+            case Fused {
+              when "type = 'Fused'";
+              uses fused-params;
+            }
+          }
+        }
+      }
+      case Transceiver {
+        when "type = 'Transceiver'";
+      }
+    }
+  }
+
+
+  grouping topo {
+    list elements {
+      key "uid";
+      leaf uid {
+        type string;
+      }
+      leaf type {
+        type identityref {
+          base type-element;
+        }
+        mandatory true;
+      }
+      leaf type_variety {
+        type string;
+        mandatory false;
+      }
+      container metadata {
+        uses location-attributes;
+      }
+      uses element-type-choice;
+    }
+    list connections {
+      config false;
+      leaf from_node {
+        type leafref {
+          path "../../elements/uid";
+        }
+      }
+      leaf to_node {
+        type leafref {
+          path "../../elements/uid";
+        }
+      }
+    }
+  }
+}

gnpy/yang/gnpy-path-computation-simplified@2020-10-22.yang

@@ -0,0 +1,559 @@
+module gnpy-path-computation-simplified {
+  yang-version 1.1;
+  namespace "gnpy:path";
+
+  prefix "gnpypc";
+
+    organization
+    "Telecom Infra Project OOPT PSE Working Group";
+
+  contact
+    "WG Web:   <https://github.com/Telecominfraproject/oopt-gnpy>
+     contact:  <mailto:ahmed.triki@orange.com>
+     contact:  <mailto:esther.lerouzic@orange.com>
+   ";
+
+  description "YANG model for gnpy path computation simplified for - 2020 - candi preversion";
+
+  revision "2020-10-22" {
+    description 
+      "draft for experimental/2020-candi";
+    reference 
+      "YANG model for path computation with gnpy inputs";
+  }
+
+  grouping effective-freq-slot{
+         /* content copied from ietf-flexi-grid-media-channel, because only M and N are needed
+            from the initial grouping.
+         */
+         description "The effective frequency slot is an attribute
+            of a media channel and, being a frequency slot, it is
+            described by its nominal central frequency and slot
+            width";
+         reference "rfc7698";
+            leaf N {
+              type uint32;
+              description
+                  "Is used to determine the Nominal Central
+                  Frequency. The set of nominal central frequencies
+                  can be built using the following expression:
+                     f = 193.1 THz + n x 0.00625 THz,
+                  where 193.1 THz is ITU-T ''anchor frequency'' for
+                  transmission over the C band, n is a positive or
+                  negative integer including 0.";
+               reference "rfc7698";
+            }
+            leaf M {
+              type int32;
+              description
+                  "Is used to determine the slot width. A slot width
+                  is constrained to be M x SWG (that is, M x 12.5 GHz),
+                  where M is an integer greater than or equal to 1.";
+               reference "rfc7698";
+    }
+  }
+
+  grouping gnpy-specific-parameters{
+    description
+      "This grouping defines the gnpy specific parameters for requests.";
+        leaf technology {
+            type string;
+            default "flexi-grid";
+            description
+          "Data plane technology type.";
+          }
+      leaf trx_type {
+        type string ;
+        mandatory true;
+        description "name of the transponder type (to be read from equipment library";
+
+      }
+      leaf trx_mode {
+        type string;
+        description "name of the transponder mode (to be read from equipment library";
+
+      }
+      list effective-freq-slot {
+        key "N";
+        uses effective-freq-slot ;
+      }
+      leaf spacing {
+        mandatory true;
+        type decimal64 {
+          fraction-digits 1;
+        }
+        units Hz;
+        description
+          "It is the spacing between channels assuming full load with
+          same channels as the requested one. multiple of 12.5 GHz";
+
+      }
+      leaf max-nb-of-channel{
+        type int32;
+        description "Nb of channel to take into account for the full load case.
+        ";
+
+      }
+      leaf output-power{
+        type decimal64 {
+          fraction-digits 5;
+        }
+        units W;
+        description "optical power setting to be used for the propagation";
+
+      }
+      leaf path_bandwidth{
+        type decimal64 {
+          fraction-digits 5;
+        }
+        mandatory true;
+        units bit/s;
+        description "Capacity required";
+      }
+  }
+
+  identity SNR-bandwidth {
+    base path-metric-type;
+    description
+      "A metric that records SNR in signal bandwidth";
+  }
+
+  identity OSNR-bandwidth {
+    base path-metric-type;
+    description
+      "A metric that records OSNR in signal bandwidth";
+  }
+
+  identity SNR-0.1nm {
+    base path-metric-type;
+    description
+      "A metric that records SNR in 0.1nm";
+  }
+
+  identity OSNR-0.1nm {
+    base path-metric-type;
+    description
+      "A metric that records OSNR in 0.1nm";
+  }
+
+  identity reference_power {
+    base path-metric-type;
+    description
+      "to be revised";
+  }
+
+  identity path_bandwidth {
+     base path-metric-type;
+     description
+       "to be revised";
+  }
+
+  grouping transponder{
+        leaf transponder-type {
+        type string ;
+        description
+          "transponder type.";
+          }
+      leaf transponder-mode {
+        type string ;
+        description
+          "transponder mode.";
+          }
+  }
+
+  grouping hop-attribute{
+    description
+      "This grouping defines the hop attribute parameters for request or response";
+    choice hop-type{
+      case tsp {
+        container transponder{
+          uses transponder ;
+        }
+      }
+      case regen {
+        container regenerator{
+          leaf regenerator-id{
+            type string ;
+          }
+          uses transponder ;
+        }
+      }
+      case pow {
+        container optical-power{
+          leaf optical-power{
+            type decimal64 {
+              fraction-digits 5;
+            }
+            units W;
+            description "not used yet. hop output (input??) power";
+          }
+        }
+      }
+    }
+
+  }
+
+  identity path-metric-type {
+    description
+      "Base identity for path metric type";
+  }
+
+  identity route-usage-type {
+    description
+      "Base identity for route usage";
+  }
+
+  identity route-include-ero {
+    base route-usage-type;
+    description
+      "Include ERO from route";
+  }
+
+  identity route-exclude-ero {
+    base route-usage-type;
+    description
+      "Exclude ERO from route";
+  }
+
+  identity route-exclude-srlg {
+    base route-usage-type;
+    description
+      "Exclude SRLG from route";
+  }
+
+  typedef te-hop-type {
+    type enumeration {
+      enum LOOSE {
+        description
+          "loose hop in an explicit path";
+      }
+      enum STRICT {
+        description
+          "strict hop in an explicit path";
+      }
+    }
+    description
+     "enumerated type for specifying loose or strict
+      paths";
+    reference "RFC3209: section-4.3.2";
+  }
+
+  typedef te-path-disjointness {
+    type bits {
+      bit node {
+        position 0;
+        description "Node disjoint.";
+      }
+      bit link {
+        position 1;
+        description "Link disjoint.";
+      }
+      bit srlg {
+        position 2;
+        description "SRLG (Shared Risk Link Group) disjoint.";
+      }
+    }
+    description
+      "Type of the resource disjointness for a TE tunnel path.";
+    reference
+      "RFC4872: RSVP-TE Extensions in Support of End-to-End
+       Generalized Multi-Protocol Label Switching (GMPLS)
+       Recovery";
+  } // te-path-disjointness
+
+    typedef accumulated-metric-type {
+      type union {
+        type uint64;
+        type decimal64 {
+          fraction-digits 2;
+        }
+      }
+      description
+          "type useable for accumulative-value";
+  }
+
+  grouping path-route-objects {
+    description
+      "List of EROs to be included or excluded when performing
+       the path computation.";
+    container explicit-route-objects {
+      description
+        "Container for the route object list";
+      list route-object-include-exclude {
+        description
+          "List of explicit route objects to include or
+           exclude in path computation";
+        leaf explicit-route-usage {
+          type identityref {
+            base route-usage-type;
+          }
+          description "Explicit-route usage.";
+        }
+        key "index";
+        uses explicit-route-hop ;
+      }
+    }
+  }
+
+  grouping generic-path-disjointness {
+    description "Path disjointness grouping";
+    leaf disjointness {
+      type te-path-disjointness;
+      description
+        "The type of resource disjointness.
+         Under primary path, disjointness level applies to
+         all secondary LSPs. Under secondary, disjointness
+         level overrides the one under primary";
+    }
+  }
+
+  grouping common-path-constraints-attributes {
+    description
+      "Common path constraints configuration grouping";
+    uses common-constraints_config;
+  }
+
+  grouping generic-path-constraints {
+    description
+      "Global named path constraints configuration
+      grouping";
+    container path-constraints {
+      description "TE named path constraints container";
+      uses common-path-constraints-attributes;
+    }
+  }
+
+
+  grouping explicit-route-hop {
+    description
+      "The explicit route subobject grouping";
+    leaf index {
+      type uint32;
+      description "ERO subobject index";
+    }
+    choice type {
+      description
+        "The explicit route subobject type";
+      case num-unnum-hop {
+        container num-unnum-hop {
+          leaf node-id {
+            //type te-node-id;
+            type string;
+            description
+              "The identifier of a node in the TE topology.";
+          }
+          leaf link-tp-id {
+            //type te-tp-id;
+            type string;
+            description
+              "TE link termination point identifier. The combination
+              of TE link ID and the TE node ID is used to identify an
+              unnumbered TE link.";
+          }
+          leaf hop-type {
+            type te-hop-type;
+            description "strict or loose hop";
+          }
+          description
+            "Numbered and Unnumbered link/node explicit route
+            subobject";
+        }
+      }
+      case label {
+        container label-hop {
+          description "Label hop type";
+          uses effective-freq-slot;
+        }
+        description
+          "The Label ERO subobject";
+      }
+      case hop-attribute{
+        uses gnpypc:hop-attribute ;
+      }
+    }
+  }
+
+  grouping common-constraints_config {
+    description
+      "Common constraints grouping that can be set on
+       a constraint set or directly on the tunnel";
+
+    container te-bandwidth {
+      uses gnpy-specific-parameters ;
+      description
+        "A requested bandwidth to use for path computation";
+    }
+  }
+
+  grouping end-points {
+    description
+      "Common grouping to define the TE tunnel end-points";
+
+    leaf source {
+      type string;
+      description "TE tunnel source address.";
+    }
+    leaf destination {
+      type string;
+      description "P2P tunnel destination address";
+    }
+    leaf src-tp-id {
+      type string;
+      description "TE tunnel source termination point identifier.";
+    }
+    leaf dst-tp-id {
+      type string;
+      description "TE tunnel destination termination point
+    identifier.";
+    }
+  }
+
+  grouping synchronization-info {
+    description "Information for sync";
+    list synchronization {
+      key "synchronization-id";
+      description "sync list";
+      leaf synchronization-id {
+        type string;
+        description "index";
+      }
+      container svec {
+        description
+         "Synchronization VECtor";
+        leaf relaxable {
+          type boolean;
+          default true;
+          description
+            "If this leaf is true, path computation process is free
+            to ignore svec content.
+            otherwise it must take into account this svec.";
+        }
+        uses generic-path-disjointness;
+        leaf-list request-id-number {
+          type string;
+          description "This list reports the set of M path computation requests that must be synchronized.";
+        }
+      }
+    }
+  }
+
+  grouping path-metric {
+    description "TE path metric type";
+    leaf metric-type {
+      type identityref {
+        base path-metric-type;
+      }
+      description "TE path metric type";
+    }
+    leaf accumulative-value {
+      type decimal64 {
+          fraction-digits 2;
+      }
+      description "TE path metric accumulative value";
+    }
+  }
+  grouping generic-path-properties {
+    description "TE generic path properties grouping";
+    container path-properties {
+      config false;
+      description "The TE path properties";
+      list path-metric {
+        key metric-type;
+        uses path-metric;
+      }
+      list z-a-path-metric {
+        key metric-type;
+        uses path-metric;
+      }
+      list path-route-objects {
+          description
+            "Container for the list of route objects either returned by
+             the computation engine or actually used by an LSP";
+          container path-route-object {
+            description
+              "List of route objects either returned by the computation
+               engine or actually used by an LSP";
+            uses explicit-route-hop;
+          }
+        }
+    }
+  }
+
+  grouping path-info {
+    uses generic-path-properties;
+    description "Path computation output information";
+  }
+
+// adding some blocking reasons and info on path in case of blocking
+
+  grouping no-path-info {
+    description "no-path-info";
+    container no-path {
+      presence "Response without path information, due to failure
+        performing the path computation";
+      leaf no-path {
+        type string;
+        mandatory true ;
+        description
+          "returned blocking reasons:
+            NO_PATH
+            NO_COMPUTED_SNR
+            NO_FEASIBLE_BAUDRATE_WITH_SPACING
+            NO_PATH_WITH_CONSTRAINT
+            NO_FEASIBLE_MODE
+            MODE_NOT_FEASIBLE
+            NO_SPECTRUM
+          ";
+        }
+      uses generic-path-properties ;
+      description "if path computation cannot identify a path,
+        rpc returns no path.";
+    }
+  }
+
+   grouping service {
+     list path-request {
+       key "request-id";
+       description "request-list";
+       leaf request-id {
+         type string;
+         mandatory true;
+         description "Each path computation request is uniquely identified by the request-id-number.";
+       }
+       leaf bidirectional {
+         type boolean;
+         mandatory true;
+         description "Specify the bidirectionality of the path";
+       }
+
+       uses end-points;
+       uses path-route-objects;
+       uses generic-path-constraints;
+     }
+     uses synchronization-info;
+   }
+
+   grouping result {
+     list response {
+       key response-id;
+       config false;
+       description "response";
+       leaf response-id {
+         type string;
+         description
+         "The list key that has to reuse request-id-number.";
+       }
+       choice response-type {
+         config false;
+         description "response-type";
+         case no-path-case {
+           uses no-path-info;
+         }
+         case path-case {
+           uses path-info;
+           description "Path computation service.";
+         }
+       }
+     }
+   }
+}

requirements.txt

@@ -10,3 +10,4 @@ scipy>=1.3.0,<2
 Sphinx>=2.4.4,<3
 sphinxcontrib-bibtex>=0.4.2,<1
 xlrd>=1.2.0,<2
+flask>=1.1.2

setup.cfg

@@ -48,3 +48,4 @@ console_scripts =
     gnpy-transmission-example = gnpy.tools.cli_examples:transmission_main_example
     gnpy-path-request = gnpy.tools.cli_examples:path_requests_run
     gnpy-convert-xls = gnpy.tools.convert:_do_convert
+    gnpy-rest = gnpy.tools.rest_example:main

tests/data/testService_services_expected.json

@@ -14,8 +14,8 @@
           "trx_mode": "mode 1",
           "effective-freq-slot": [
             {
-              "N": "null",
-              "M": "null"
+              "N": null,
+              "M": null
             }
           ],
           "spacing": 50000000000.0,
@@ -39,8 +39,8 @@
           "trx_mode": "mode 1",
           "effective-freq-slot": [
             {
-              "N": "null",
-              "M": "null"
+              "N": null,
+              "M": null
             }
           ],
           "spacing": 50000000000.0,
@@ -64,8 +64,8 @@
           "trx_mode": "mode 1",
           "effective-freq-slot": [
             {
-              "N": "null",
-              "M": "null"
+              "N": null,
+              "M": null
             }
           ],
           "spacing": 50000000000.0,

tests/data/testTopology_services_expected.json

@@ -14,8 +14,8 @@
           "trx_mode": "mode 1",
           "effective-freq-slot": [
             {
-              "N": "null",
-              "M": "null"
+              "N": null,
+              "M": null
             }
           ],
           "spacing": 50000000000.0,
@@ -39,8 +39,8 @@
           "trx_mode": "mode 1",
           "effective-freq-slot": [
             {
-              "N": "null",
-              "M": "null"
+              "N": null,
+              "M": null
             }
           ],
           "spacing": 50000000000.0,
@@ -104,8 +104,8 @@
           "trx_mode": "mode 1",
           "effective-freq-slot": [
             {
-              "N": "null",
-              "M": "null"
+              "N": null,
+              "M": null
             }
           ],
           "spacing": 50000000000.0,
@@ -129,8 +129,8 @@
           "trx_mode": "mode 2",
           "effective-freq-slot": [
             {
-              "N": "null",
-              "M": "null"
+              "N": null,
+              "M": null
             }
           ],
           "spacing": 75000000000.0,
@@ -154,8 +154,8 @@
           "trx_mode": "mode 2",
           "effective-freq-slot": [
             {
-              "N": "null",
-              "M": "null"
+              "N": null,
+              "M": null
             }
           ],
           "spacing": 75000000000.0,
@@ -179,8 +179,8 @@
           "trx_mode": "mode 2",
           "effective-freq-slot": [
             {
-              "N": "null",
-              "M": "null"
+              "N": null,
+              "M": null
             }
           ],
           "spacing": 75000000000.0,

tests/data/testTopology_testservices.json

@@ -14,8 +14,8 @@
           "trx_mode": "16QAM",
           "effective-freq-slot": [
             {
-              "n": "null",
-              "m": "null"
+              "N":"null",
+              "M":"null"
             }
           ],
           "spacing": 50000000000.0,
@@ -39,8 +39,8 @@
           "trx_mode": "PS_SP64_1",
           "effective-freq-slot": [
             {
-              "n": "null",
-              "m": "null"
+              "N":"null",
+              "M":"null"
             }
           ],
           "spacing": 50000000000.0,
@@ -64,8 +64,8 @@
           "trx_mode": "PS_SP64_1",
           "effective-freq-slot": [
             {
-              "n": "null",
-              "m": "null"
+              "N":"null",
+              "M":"null"
             }
           ],
           "spacing": 50000000000.0,
@@ -89,8 +89,8 @@
           "trx_mode": "PS_SP64_1",
           "effective-freq-slot": [
             {
-              "n": "null",
-              "m": "null"
+              "N":"null",
+              "M":"null"
             }
           ],
           "spacing": 50000000000.0,
@@ -135,8 +135,8 @@
           "trx_mode": "mode 2 - fake",
           "effective-freq-slot": [
             {
-              "n": "null",
-              "m": "null"
+              "N":"null",
+              "M":"null"
             }
           ],
           "spacing": 75000000000.0,
@@ -160,8 +160,8 @@
           "trx_mode": "mode 2",
           "effective-freq-slot": [
             {
-              "n": "null",
-              "m": "null"
+              "N":"null",
+              "M":"null"
             }
           ],
           "spacing": 75000000000.0,
@@ -185,8 +185,8 @@
           "trx_mode": "PS_SP64_1",
           "effective-freq-slot": [
             {
-              "n": "null",
-              "m": "null"
+              "N":"null",
+              "M":"null"
             }
           ],
           "spacing": 50000000000.0,
@@ -223,8 +223,8 @@
           "trx_mode": "mode 3",
           "effective-freq-slot": [
             {
-              "n": "null",
-              "m": "null"
+              "N":"null",
+              "M":"null"
             }
           ],
           "spacing": 62500000000.0,
@@ -261,8 +261,8 @@
           "trx_mode": "PS_SP64_1",
           "effective-freq-slot": [
             {
-              "n": "null",
-              "m": "null"
+              "N":"null",
+              "M":"null"
             }
           ],
           "spacing": 50000000000.0,
@@ -286,8 +286,8 @@
           "trx_mode": "PS_SP64_1",
           "effective-freq-slot": [
             {
-              "n": "null",
-              "m": "null"
+              "N":"null",
+              "M":"null"
             }
           ],
           "spacing": 50000000000.0,
@@ -332,8 +332,8 @@
           "trx_mode": "16QAM",
           "effective-freq-slot": [
             {
-              "n": "null",
-              "m": "null"
+              "N":"null",
+              "M":"null"
             }
           ],
           "spacing": 50000000000.0,
@@ -357,8 +357,8 @@
           "trx_mode": "mode 1",
           "effective-freq-slot": [
             {
-              "n": "null",
-              "m": "null"
+              "N":"null",
+              "M":"null"
             }
           ],
           "spacing": 50000000000.0,
@@ -382,8 +382,8 @@
           "trx_mode": "PS_SP64_1",
           "effective-freq-slot": [
             {
-              "n": "null",
-              "m": "null"
+              "N":"null",
+              "M":"null"
             }
           ],
           "spacing": 50000000000.0,
@@ -407,8 +407,8 @@
           "trx_mode": null,
           "effective-freq-slot": [
             {
-              "n": "null",
-              "m": "null"
+              "N":"null",
+              "M":"null"
             }
           ],
           "spacing": 50000000000.0,
@@ -453,8 +453,8 @@
           "trx_mode": null,
           "effective-freq-slot": [
             {
-              "n": "null",
-              "m": "null"
+              "N":"null",
+              "M":"null"
             }
           ],
           "spacing": 50000000000.0,
@@ -478,8 +478,8 @@
           "trx_mode": null,
           "effective-freq-slot": [
             {
-              "n": "null",
-              "m": "null"
+              "N":"null",
+              "M":"null"
             }
           ],
           "spacing": 75000000000.0,
@@ -503,8 +503,8 @@
           "trx_mode": null,
           "effective-freq-slot": [
             {
-              "n": "null",
-              "m": "null"
+              "N":"null",
+              "M":"null"
             }
           ],
           "spacing": 50000000000.0,
@@ -528,8 +528,8 @@
           "trx_mode": null,
           "effective-freq-slot": [
             {
-              "n": "null",
-              "m": "null"
+              "N":"null",
+              "M":"null"
             }
           ],
           "spacing": 75000000000.0,
@@ -553,8 +553,8 @@
           "trx_mode": null,
           "effective-freq-slot": [
             {
-              "n": "null",
-              "m": "null"
+              "N":"null",
+              "M":"null"
             }
           ],
           "spacing": 30000000000.0,

tests/test_disjunction.py

@@ -129,6 +129,7 @@ def create_rq(equipment, srce, dest, bdir, nd_list, ls_list):
     f_max_from_si = params['f_max']
     params['nb_channel'] = automatic_nch(f_min, f_max_from_si, params['spacing'])
     params['path_bandwidth'] = 100000000000.0
+    params['effective_freq_slot'] = None
     requests_list.append(PathRequest(**params))
     return requests_list
 

tests/test_parser.py

@@ -418,6 +418,7 @@ def test_excel_ila_constraints(source, destination, route_list, hoptype, expecte
         'nb_channel': 0,
         'power': 0,
         'path_bandwidth': 0,
+        'effective_freq_slot': None
     }
     request = PathRequest(**params)