Network as Code

https://networkascode.nokia.io/docs
Admin
Network as Code provides APIs and documentation for integrating various network capabilities and...
Tokens:29,459
Snippets:109
Trust Score:7.5
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install TypeScript and SDK for TypeScript

Source: https://networkascode.nokia.io/docs/getting-started

Commands to install TypeScript as a development dependency and the Network as Code SDK for TypeScript using npm.

```bash
npm i typescript --save-dev
npm i network-as-code
```

--------------------------------

### Setup Python Virtual Environment

Source: https://networkascode.nokia.io/docs/getting-started

Commands to navigate into the project directory, create a Python virtual environment named 'env', and activate it. Requires Python 3.11 or higher.

```bash
cd nac-hello-world
python3 -m venv env
source env/bin/activate
```

--------------------------------

### Install Python Network as Code SDK

Source: https://networkascode.nokia.io/docs/getting-started

Command to install the latest version of the Network as Code SDK for Python using pip. Ensure your Python version is 3.11 or higher.

```bash
pip install network_as_code
```

--------------------------------

### Initialize TypeScript Project

Source: https://networkascode.nokia.io/docs/getting-started

Commands to navigate into the project directory and initialize a new Node.js/TypeScript project using npm. Requires Node.js version 20 or higher.

```bash
cd nac-hello-world
npm init
```

--------------------------------

### Initialize NetworkAsCodeClient in Python

Source: https://networkascode.nokia.io/docs/getting-started

Python code snippet to import the Network as Code library and create an instance of the NetworkAsCodeClient. Requires your API key.

```python
import network_as_code as nac

# We begin by creating a Network as Code client
client = nac.NetworkAsCodeClient(
    token="<your-application-key-here>"
)
```

--------------------------------

### Initialize NetworkAsCodeClient in TypeScript

Source: https://networkascode.nokia.io/docs/getting-started

TypeScript code snippet to import and initialize the NetworkAsCodeClient. Replace the placeholder with your actual API key.

```typescript
import { NetworkAsCodeClient } from 'network-as-code';

// We begin by creating a Network as Code client
const client = new NetworkAsCodeClient(
    "<your-application-key-here>"
);
```

--------------------------------

### Create Python Project Directory

Source: https://networkascode.nokia.io/docs/getting-started

Command to create a new directory for a Python Network as Code project. This is the first step in setting up your local development environment.

```bash
mkdir nac-hello-world
```

--------------------------------

### Configure TypeScript Project

Source: https://networkascode.nokia.io/docs/getting-started

Command to initialize a TypeScript configuration file (`tsconfig.json`) and instructions to ensure `module` and `target` are set to `esnext` within the file.

```bash
npx tsc --init
```

--------------------------------

### Slice Notifications SDK - Python and TypeScript Example

Source: https://networkascode.nokia.io/docs/slicing/slice-notifications

Demonstrates how to create a Network as Code client, create a slice with notification configurations, and set up a FastAPI application to receive and process slice status notifications. It includes models for notifications and an example POST endpoint.

```python
import time

from fastapi import FastAPI, Header

from pydantic import BaseModel

from typing_extensions import Annotated
from typing import Union

import network_as_code as nac

from network_as_code.models.slice import (
    NetworkIdentifier,
    SliceInfo,
)

# We begin by creating a Network as Code client
client = nac.NetworkAsCodeClient(
    token="<your-application-key-here>"
)

# Then, we create a slice
my_slice = client.slices.create(
    name="slice-name",
    network_id = NetworkIdentifier(mcc="236", mnc="30"),
    slice_info = SliceInfo(service_type="eMBB", differentiator="123456"),
    # Use HTTPS to send notifications
    notification_url="https://example.com/notifications",
    notification_auth_token="replace-with-your-auth-token"
)

# Our web server for receiving notifications

app = FastAPI()

class Notification(BaseModel):
    resource: str
    action: str
    state: str

# We'll keep track of when we are retiring the slice between the notifications
retiring = False

@app.post("/notifications")
def receive_notification(
    notification: Notification,
    authorization: Annotated[Union[str, None], Header]
):
    if authorization == "Bearer my-token":
        # We can now react to the notifications
        # based on the Notification object
        print(notification)

```

--------------------------------

### Initialize Network as Code Client

Source: https://context7.com/context7/networkascode_nokia_io/llms.txt

Initializes the Network as Code client using an application key obtained from the dashboard. This client is then used to access platform capabilities and manage devices. Both Python and TypeScript examples are provided.

```python
import network_as_code as nac

# Create client with application key from dashboard
client = nac.NetworkAsCodeClient(
    token="<your-application-key-here>"
)

# Create device object for operations
my_device = client.devices.get(
    phone_number="+36721601234567"
)
```

```typescript
import { NetworkAsCodeClient } from 'network-as-code';

const client = new NetworkAsCodeClient({
  token: '<your-application-key-here>'
});

const myDevice = client.devices.get({
  phoneNumber: '+36721601234567'
});
```

--------------------------------

### Create QoD Session Parameters for cURL

Source: https://networkascode.nokia.io/docs/quality-on-demand/qod-notifications-and-life-cycle

Provides a cURL command example for creating a Quality-of-Service-on-Demand (QoD) session. It highlights the necessary parameters such as QoS profile, service IP, duration, and notification endpoint, along with how to include an authentication token.

```cURL
curl -X POST https://network-as-code.nokia.com/api/v1/sessions \
     -H "Content-Type: application/json" \
     -d '{ \
         "profile": "string", \
         "service_ipv4": "string", \
         "duration": 86400, \
         "notification_url": "http://your-server.com/notify", \
         "notification_auth_token": "your-token" \
     }'
```

--------------------------------

### Create QoD Session with Notifications - Python

Source: https://networkascode.nokia.io/docs/quality-on-demand/qod-notifications-and-life-cycle

Demonstrates how to create a Quality-of-Service on Demand (QoD) session using the network_as_code library in Python. It includes setting service details, QoS profile, duration, and crucially, a notification URL and authentication token for receiving session updates. The example also shows how to retrieve a list of all QoD sessions for a device.

```python
import network_as_code as nac

from network_as_code.models.device import DeviceIpv4Addr

# Begin by creating a client for Network as Code:
client = nac.NetworkAsCodeClient(
    token="<your-application-key-here>",
)

# Then, create a device object.
# Remember to assign its phone number and current IP address(es):
my_device = client.devices.get(
    ipv4_address=DeviceIpv4Addr(
        public_address="233.252.0.2",
        private_address="192.0.2.25",
        public_port=80
    ),
    ipv6_address="2001:db8:1234:5678:9abc:def0:fedc:ba98",
    # The phone number does not accept spaces or parentheses
    phone_number="+36721601234567"
)

# Create a QoD session with QOS_L (large bandwidth)
# and get notifications
my_session = my_device.create_qod_session(
    service_ipv4="233.252.0.2",
    service_ipv6="2001:db8:1234:5678:9abc:def0:fedc:ba98",
    profile="QOS_L",
    duration=3600,
    # Use HTTPS to send notifications
    notification_url="https://notify.me/here",
    notification_auth_token="replace-with-your-auth-token"
)

# Show a list of all the QoD sessions associated with a device
print(my_device.sessions())

```

--------------------------------

### Get Congestion Subscriptions using Python

Source: https://networkascode.nokia.io/docs/network-insights/get-congestion

This Python code snippet demonstrates how to retrieve a list of all congestion subscriptions, access a specific subscription by its index, and fetch a subscription by its unique ID. It requires the `network_as_code` library and assumes prior client and device object creation, as well as an active congestion subscription.

```python
import network_as_code as nac

from datetime import datetime, timezone, timedelta

from network_as_code.models.device import DeviceIpv4Addr

# Create a client and device objects as previously shown
client = nac.NetworkAsCodeClient(
    token="<your-application-key-here>"
)

my_device = client.devices.get(
    "device@testcsp.net",
    ipv4_address=DeviceIpv4Addr(
        public_address="192.0.2.3",
        private_address="192.0.2.204",
        public_port=80
    ),
)

# Subscribe your device to Congestion notifications
congestion_subscription = client.insights.subscribe_to_congestion_info(
    my_device,
    # Set the duration of your subscription to congestion insights,
    # e.g.: it can end in `n` days starting from now.
    subscription_expire_time=datetime.now(timezone.utc) + timedelta(days=1),
    # Set a notification URL with auth token to receive updates
    notification_url="https://example.com/notify",
    notification_auth_token="my-secret-token"
)

# Get a list of congestion subscriptions
subscriptions = client.insights.get_congestion_subscriptions()

# Get only the first or one subscription at a time by its index
first_subscription = client.insights.get_congestion_subscriptions()[0]

# Get a subscription previously created by its ID
one_subscription = client.insights.get_congestion_subscription(
    congestion_subscription.id
)
```

--------------------------------

### Create QoD Session with Port Ranges (Python)

Source: https://networkascode.nokia.io/docs/quality-on-demand/qod-sessions

This Python example shows how to create a Quality of Service (QoS) session while specifying port ranges for both the service and the device. This allows for more granular control over network traffic by defining specific communication endpoints. It utilizes the `PortsSpec` and `PortRange` models from the `network_as_code.models.session` module.

```python
from network_as_code.models.session import PortsSpec, PortRange

my_session = my_device.create_qod_session(
    service_ipv4="233.252.0.2",
    service_ipv6="2001:db8:1234:5678:9abc:def0:fedc:ba98",
    service_ports=PortsSpec(ranges=[PortRange(start=80, end=443)]),
    device_ports=PortsSpec(ranges=[PortRange(start=80, end=443)]),
    profile="QOS_L",
    duration=3600
)

```

--------------------------------

### Create QoD Session with Specific Duration (Python)

Source: https://networkascode.nokia.io/docs/quality-on-demand/qod-sessions

This snippet demonstrates how to create a Quality of Service (QoS) session with a specified duration using the Network as Code Python library. It initializes a client, retrieves a device, and then creates a QoD session with a profile and duration in seconds. The code also shows how to access the session's duration, start time, and expiration time.

```python
import network_as_code as nac

from network_as_code.models.device import DeviceIpv4Addr

# Begin by creating a client for Network as Code:
client = nac.NetworkAsCodeClient(
    token="<your-application-key-here>",
)

# Then, create a device object.
# Remember to assign its phone number and current IP address(es):
my_device = client.devices.get(
    ipv4_address=DeviceIpv4Addr(
        public_address="233.252.0.2",
        private_address="192.0.2.25",
        public_port=80
    ),
    # The phone number does not accept spaces or parentheses
    phone_number="+36721601234567"
)

# Create a QoD session with QOS_L (large bandwidth)
# that lasts for 3,600 seconds (1 hour):
my_session = my_device.create_qod_session(
    service_ipv4="233.252.0.2",
    service_ipv6="2001:db8:1234:5678:9abc:def0:fedc:ba98",
    profile="QOS_L",
    duration=3600
)

# You can show the duration of a given session
print(my_session.duration)

# Or use these to check when your session started/expires:
print(my_session.started_at)
print(my_session.expires_at)

```

--------------------------------

### QoD Sessions with Port Specifications

Source: https://context7.com/context7/networkascode_nokia_io/llms.txt

Allows fine-grained control over bandwidth for specific application ports within Quality of Service sessions. This can be achieved by specifying ranges or lists of ports for both the service and the device. This example is in Python.

```python
from network_as_code.models.session import PortsSpec, PortRange

# Create session with port ranges
my_session = my_device.create_qod_session(
    service_ipv4="233.252.0.2",
    service_ports=PortsSpec(ranges=[PortRange(start=80, end=443)]),
    device_ports=PortsSpec(ranges=[PortRange(start=80, end=443)]),
    profile="QOS_L",
    duration=3600
)

# Or with specific port lists
my_session = my_device.create_qod_session(
    service_ipv4="233.252.0.2",
    service_ports=PortsSpec(ports=[80, 443]),
    device_ports=PortsSpec(ports=[1600, 2000]),
    profile="QOS_M",
    duration=3600
)
```

--------------------------------

### Get all QoD sessions

Source: https://networkascode.nokia.io/docs/quality-on-demand/qod-sessions

Retrieves a list of all Quality of Service (QoS) sessions associated with a specific device.

```APIDOC
## GET /devices/{device_id}/sessions

### Description
Retrieves a list of all Quality of Service (QoS) sessions associated with a specific device.

### Method
GET

### Endpoint
`/devices/{device_id}/sessions`

### Parameters
#### Path Parameters
- **device_id** (string) - Required - The unique identifier of the device.

### Response
#### Success Response (200)
- **sessions** (array) - A list of session objects.
  - **id** (string) - Session resource identifier.
  - **profile** (string) - The QoS profile that indicates the connection type to be prioritized.
  - **status** (string) - QoD session status (`REQUESTED`, `AVAILABLE`, `UNAVAILABLE`).
  - **started_at** (datetime) - Timezone-aware timestamp when the session started.
  - **expires_at** (datetime) - Timezone-aware timestamp when the session expires.
  - **service_ipv4** (string) - The service identified by the application IPv4 address.
  - **service_ipv6** (string) - The service identified by the application IPv6 address.
  - **service_ports** (integer) - A list of ports or a range of ports for a service.
  - **device_ports** (integer) - A list of ports or a range of ports for a device.
  - **duration** (integer) - The length of the QoD session in seconds (maximum: 86400).

#### Response Example
{
  "sessions": [
    {
      "id": "sess_12345",
      "profile": "DOWNLINK_L_UPLINK_L",
      "status": "AVAILABLE",
      "started_at": "2023-10-27T10:00:00Z",
      "expires_at": "2023-10-27T11:00:00Z",
      "service_ipv4": "233.252.0.2",
      "service_ipv6": "2001:db8:1234:5678:9abc:def0:fedc:ba98",
      "service_ports": 80,
      "device_ports": 8080,
      "duration": 3600
    }
  ]
}
```

--------------------------------

### QoD Notification Schema Example

Source: https://networkascode.nokia.io/docs/quality-on-demand/qod-notifications-and-life-cycle

Demonstrates the JSON schema structure for Quality-of-Service-on-Demand (QoD) notifications. This schema outlines the expected fields for events related to QoS status changes, including session ID, status, and additional information.

```JSON
{
   "id":"string",
   "source":"string",
   "type":"org.camaraproject.qod.v0.qos-status-changed",
   "specversion":"1.0",
   "datacontenttype":"application/json",
   "time":"2024-04-30T13:05:29.189Z",
   "data":{
      "sessionId":"string",
      "qosStatus":"UNAVAILABLE",
      "statusInfo":"DELETE_REQUESTED"
   }
}
```

--------------------------------

### Test Device Identifiers with Simulators (Python)

Source: https://context7.com/context7/networkascode_nokia_io/llms.txt

Retrieves simulator devices using the Network As Code client for development and testing purposes. It demonstrates how to get devices by their Network Access Identifier (NAI) and by their phone number format, specifying simulator-specific prefixes.

```python
# Network access identifier format for simulators
test_device_nai = client.devices.get(
    network_access_identifier="myprojectdevice1@testcsp.net"
)

# Phone number format for simulators (prefixes: +3672, +3670, +3637)
test_device_phone = client.devices.get(
    phone_number="+3672123456"
)
```

--------------------------------

### Create and Manage Quality of Service (QoD) Sessions

Source: https://context7.com/context7/networkascode_nokia_io/llms.txt

Establishes prioritized network connections with guaranteed bandwidth and latency. This includes creating sessions, accessing their properties, extending their duration, deleting them, or clearing all sessions for a device. Examples are shown in Python and via a REST API using curl.

```python
import network_as_code as nac
from network_as_code.models.device import DeviceIpv4Addr

client = nac.NetworkAsCodeClient(
    token="<your-application-key-here>"
)

# Create device with IP addresses
my_device = client.devices.get(
    ipv4_address=DeviceIpv4Addr(
        public_address="233.252.0.2",
        private_address="192.0.2.25",
        public_port=80
    ),
    ipv6_address="2001:db8:1234:5678:9abc:def0:fedc:ba98",
    phone_number="+36721601234567"
)

# Create QoD session with large bandwidth profile for 1 hour
my_session = my_device.create_qod_session(
    service_ipv4="233.252.0.2",
    service_ipv6="2001:db8:1234:5678:9abc:def0:fedc:ba98",
    profile="DOWNLINK_L_UPLINK_L",  # or "QOS_L", "QOS_M", "QOS_S", "QOS_E"
    duration=3600
)

# Access session properties
print(f"Session ID: {my_session.id}")
print(f"Status: {my_session.status}")
print(f"Started: {my_session.started_at}")
print(f"Expires: {my_session.expires_at}")

# Extend session by 5 minutes
my_session.extend(300)

# Delete session when finished
my_session.delete()

# Or delete all device sessions
my_device.clear_sessions()
```

```bash
# Create QoD session via REST API
curl -X POST https://api.network-as-code.io/qod/v1/sessions \
  -H "Authorization: Bearer <your-application-key>" \
  -H "Content-Type: application/json" \
  -d '{
    "device": {
      "phoneNumber": "+36721601234567",
      "ipv4Address": {
        "publicAddress": "233.252.0.2",
        "privateAddress": "192.0.2.25",
        "publicPort": 80
      }
    },
    "serviceIpv4": "233.252.0.2",
    "profile": "QOS_L",
    "duration": 3600
  }'
```

--------------------------------

### Retrieve Latest Device Swap Date with Python SDK

Source: https://networkascode.nokia.io/docs/device-swap/device-swap

This Python code snippet demonstrates how to use the Network as Code SDK to retrieve the timestamp of the last device swap or SIM installation for a given phone number. It requires initializing the client with an application key and then fetching the device object.

```python
import network_as_code as nac

from network_as_code.models.device import Device

# Initialize the client object with your application key
client = nac.NetworkAsCodeClient(
    token="<your-application-key-here>"
)

# Then, create a device object for the phone number you want to check
my_device = client.devices.get(
    # The phone number does not accept spaces or parentheses
    phone_number="+99999991000"
)

# The date of the last device swap can be retrieved like so:
device_swap_date = my_device.get_device_swap_date()

# Otherwise it behaves like a regular datetime object
print(f"Last device swap (or SIM installation) happened on {device_swap_date.isoformat()}")
```

--------------------------------

### Get all QoD sessions using Python

Source: https://networkascode.nokia.io/docs/quality-on-demand/qod-sessions

Retrieves all Quality of Service (QoS) on Demand (QoD) sessions associated with a network device. It requires initializing the NetworkAsCode client with an application key and specifying the device by its phone number or IP address. The function returns a list of session objects.

```Python
import network_as_code as nac

from network_as_code.models.device import DeviceIpv4Addr

client = nac.NetworkAsCodeClient(
    token="<your-application-key-here>"
)

my_device = client.devices.get(
    # The phone number does not accept spaces or parentheses
    phone_number="+36721601234567"
    ipv4_address=DeviceIpv4Addr(
        public_address="233.252.0.2",
        private_address="192.0.2.25",
        public_port=80,
    ),
)

# Create a session
my_session = my_device.create_qod_session(
    service_ipv4="233.252.0.2",
    service_ipv6="2001:db8:1234:5678:9abc:def0:fedc:ba98",
    profile="DOWNLINK_L_UPLINK_L",
    duration=3600
)

# Get all sessions
all_sessions = my_device.sessions()

# Notice how we can use the number '0'
# to retrieve our first session in this case:
first_session = all_sessions[0]
```

--------------------------------

### Get Device by Multiple Identifiers

Source: https://context7.com/context7/networkascode_nokia_io/llms.txt

Combines multiple identification methods (phone number, IPv4, IPv6) to uniquely identify a device. This comprehensive approach ensures accurate device retrieval, especially in complex network environments.

```python
from network_as_code.models.device import DeviceIpv4Addr

device = client.devices.get(
    phone_number="+36721601234567",
    ipv4_address=DeviceIpv4Addr(
        public_address="233.252.0.2",
        private_address="192.0.2.25",
        public_port=80
    ),
    ipv6_address="2001:db8:1234:5678:9abc:def0:fedc:ba98"
)
```

--------------------------------

### Retrieve Call Forwarding Services using Python SDK

Source: https://networkascode.nokia.io/docs/call-forwarding-signal/call-forwarding-signal

This Python code snippet demonstrates how to use the Network as Code client to retrieve active call forwarding services for a given phone number. It requires an application key for authentication and returns information about the call forwarding setup.

```python
import network_as_code as nac

# We begin by creating a Network as Code client
client = nac.NetworkAsCodeClient(
    token="<your-application-key-here>"
)

# Then, create a device object for the phone number you want to check
my_device = client.devices.get(
    # The phone number accepts the "+" sign, but not spaces or "()" marks
    phone_number="+99999991111"
)

# Information about an active "call forwarding setup" for the given device
# can be retrieved like so:
services = my_device.get_call_forwarding()

# Show active Call Forwarding services
print(services)
```

--------------------------------

### Identify Device with IPv4 Address and Phone Number (TypeScript)

Source: https://networkascode.nokia.io/docs/general-concepts/identifying-devices

This TypeScript code snippet illustrates identifying a mobile network device using its IPv4 address and phone number through the Network as Code client. It mirrors the Python example by using the DeviceIpv4Addr model for IP address details and highlights the necessity of providing additional identifying information beyond just the IPv4 address. The phone number format constraints are also applicable here.

```typescript
import nac from "network-as-code";
import { DeviceIpv4Addr } from "network-as-code/models/device";

const client = new nac.NetworkAsCodeClient({
  token: "<your-application-key-here>"
});

const myDevice = await client.devices.get(
  "device@testcsp.net",
  // Provide either the public and private address
  // or the public address and port.
  // Devices cannot be identified by their IPv4 address alone.
  {
    ipv4Address: new DeviceIpv4Addr({
      publicAddress: "233.252.0.2",
      privateAddress: "192.0.2.25",
      publicPort: 80
    }),
    ipv6Address: "2001:db8:1234:5678:9abc:def0:fedc:ba98",
    // The phone number does not accept spaces or parentheses
    phoneNumber: "+36721601234567"
  }
);

```

--------------------------------

### Create NetworkAsCodeClient Object

Source: https://networkascode.nokia.io/docs/general-concepts/network-as-code-client

Instantiates the NetworkAsCodeClient to serve as the entry point for Network as Code functionalities. It requires an application key for authentication, which is obtained from the dashboard.

```python
import network_as_code as nac

from network_as_code.models.device import Device, DeviceIpv4Addr

client = nac.NetworkAsCodeClient(
    token="<your-application-key-here>",
)
```

```typescript
import network_as_code as nac

from network_as_code.models.device import Device, DeviceIpv4Addr

const client = new nac.NetworkAsCodeClient(
    token="<your-application-key-here>",
);
```

--------------------------------

### Create QoD Session using Network as Code SDK

Source: https://networkascode.nokia.io/docs/quality-on-demand/qod-sessions

Demonstrates how to create a Quality of Service on Demand (QoD) session using the Network as Code Python SDK. It initializes a client, retrieves a device by its IP address, and then creates a QoD session with a specified service IP, QoS profile, and duration. Dependencies include the 'network_as_code' library. Inputs are application key, device IP addresses, phone number, service IP addresses, QoS profile string, and duration in seconds. Outputs a QoD session object.

```python
import network_as_code as nac

from network_as_code.models.device import DeviceIpv4Addr

# We begin by creating a Network as Code client
client = nac.NetworkAsCodeClient(
    token="<your-application-key-here>"
)

my_device = client.devices.get(
    ipv4_address=DeviceIpv4Addr(
        public_address="233.252.0.2",
        private_address="192.0.2.25",
        public_port=80
    ),
    ipv6_address="2001:db8:1234:5678:9abc:def0:fedc:ba98",
    # The phone number does not accept spaces or parentheses
    phone_number="+36721601234567"
)

# ...and create a QoD session for the device
my_session = my_device.create_qod_session(
    service_ipv4="233.252.0.2",
    service_ipv6="2001:db8:1234:5678:9abc:def0:fedc:ba98",
    profile="DOWNLINK_L_UPLINK_L",
    # We create the session for 3600 seconds, so up to an hour
    duration=3600
)
```

--------------------------------

### Get Device Roaming Status

Source: https://networkascode.nokia.io/docs/status/device-roaming

Retrieves the current roaming status of a specific device.

```APIDOC
## GET /devices/{deviceId}/roaming

### Description
Checks the current roaming status of a specified device.

### Method
GET

### Endpoint
/devices/{deviceId}/roaming

### Parameters
#### Path Parameters
- **deviceId** (string) - Required - The unique identifier of the device.

### Response
#### Success Response (200)
- **isRoaming** (boolean) - Indicates if the device is currently roaming.

#### Response Example
```json
{
  "isRoaming": true
}
```
```

--------------------------------

### Initialize NetworkAsCodeClient in Python

Source: https://networkascode.nokia.io/docs/location/index-loc

Initializes the NetworkAsCodeClient, which serves as the entry point for all Network as Code functionalities. It requires an application key (token) for authentication.

```python
client = nac.NetworkAsCodeClient(token="<your-application-key-here>")
```

--------------------------------

### Get session by ID

Source: https://networkascode.nokia.io/docs/quality-on-demand/qod-sessions

Retrieves a specific Quality of Service (QoS) session by its unique identifier.

```APIDOC
## GET /sessions/{session_id}

### Description
Retrieves a specific Quality of Service (QoS) session by its unique identifier.

### Method
GET

### Endpoint
`/sessions/{session_id}`

### Parameters
#### Path Parameters
- **session_id** (string) - Required - The unique identifier of the session.

### Response
#### Success Response (200)
- **session** (object) - The requested session object.
  - **id** (string) - Session resource identifier.
  - **profile** (string) - The QoS profile that indicates the connection type to be prioritized.
  - **status** (string) - QoD session status (`REQUESTED`, `AVAILABLE`, `UNAVAILABLE`).
  - **started_at** (datetime) - Timezone-aware timestamp when the session started.
  - **expires_at** (datetime) - Timezone-aware timestamp when the session expires.
  - **service_ipv4** (string) - The service identified by the application IPv4 address.
  - **service_ipv6** (string) - The service identified by the application IPv6 address.
  - **service_ports** (integer) - A list of ports or a range of ports for a service.
  - **device_ports** (integer) - A list of ports or a range of ports for a device.
  - **duration** (integer) - The length of the QoD session in seconds (maximum: 86400).

#### Response Example
{
  "session": {
    "id": "sess_12345",
    "profile": "DOWNLINK_L_UPLINK_L",
    "status": "AVAILABLE",
    "started_at": "2023-10-27T10:00:00Z",
    "expires_at": "2023-10-27T11:00:00Z",
    "service_ipv4": "233.252.0.2",
    "service_ipv6": "2001:db8:1234:5678:9abc:def0:fedc:ba98",
    "service_ports": 80,
    "device_ports": 8080,
    "duration": 3600
  }
}
```

--------------------------------

### Client Initialization

Source: https://context7.com/context7/networkascode_nokia_io/llms.txt

Initialize the Network as Code client with your application key to access all platform capabilities. The client can be initialized with a token and used to retrieve device objects.

```APIDOC
## Client Initialization

### Description
Initialize the Network as Code client with your application key to access all platform capabilities.

### Method
N/A (Client Initialization)

### Endpoint
N/A (Client Initialization)

### Parameters
#### Request Body
- **token** (string) - Required - Your application key obtained from the Network as Code Dashboard.

### Request Example
```python
import network_as_code as nac

client = nac.NetworkAsCodeClient(
    token="<your-application-key-here>"
)
```
```typescript
import { NetworkAsCodeClient } from 'network-as-code';

const client = new NetworkAsCodeClient({
  token: '<your-application-key-here>'
});
```

### Response
#### Success Response (N/A)
N/A

#### Response Example
N/A
```

--------------------------------

### Get Device by IPv6 Address

Source: https://context7.com/context7/networkascode_nokia_io/llms.txt

Identifies a device using its IPv6 address. This method is essential for networks that utilize IPv6 addressing for device communication.

```python
device = client.devices.get(
    ipv6_address="2001:db8:1234:5678:9abc:def0:fedc:ba98"
)
```

--------------------------------

### GET /devices/{device_identifier}/connectivity

Source: https://networkascode.nokia.io/docs/status/device-connectivity

Retrieves the current connectivity status of a specified device. The response indicates whether the device is connected for data, SMS, or not connected at all.

```APIDOC
## GET /devices/{device_identifier}/connectivity

### Description
Retrieves the current connectivity status of a specified device.

### Method
GET

### Endpoint
/devices/{device_identifier}/connectivity

### Parameters
#### Path Parameters
- **device_identifier** (string) - Required - The unique identifier of the device (e.g., phone number).

#### Query Parameters
None

#### Request Body
None

### Request Example
GET /devices/+99999991000/connectivity

### Response
#### Success Response (200)
- **status** (string) - The connectivity status. Possible values are `CONNECTED_DATA`, `CONNECTED_SMS`, `NOT_CONNECTED`.

#### Response Example
```json
{
  "status": "CONNECTED_DATA"
}
```
```

--------------------------------

### Get QoD Session

Source: https://networkascode.nokia.io/docs/quality-on-demand/qod-sessions

This endpoint retrieves details of an existing QoD session. Sessions can be retrieved using their unique ID or index, which is useful for monitoring or managing ongoing sessions.

```APIDOC
## GET /sessions/{sessionId}

### Description
Retrieves details of a specific QoD session.

### Method
GET

### Endpoint
`/sessions/{sessionId}`

### Parameters
#### Path Parameters
- **sessionId** (string) - Required - The unique identifier of the session to retrieve.

#### Query Parameters
None

#### Request Body
None

### Response
#### Success Response (200)
- **session_id** (string) - The unique identifier of the session.
- **device_id** (string) - The identifier of the device the session is associated with.
- **service_ipv4** (string) - The service IPv4 address.
- **service_ipv6** (string) - The service IPv6 address.
- **profile** (string) - The QoS profile of the session.
- **duration** (integer) - The current duration of the session in seconds.
- **started_at** (string) - The timestamp when the session started (ISO 8601 format).
- **expires_at** (string) - The timestamp when the session expires (ISO 8601 format).

#### Response Example
```json
{
  "session_id": "sess-12345abcde",
  "device_id": "dev-abcdef1234",
  "service_ipv4": "233.252.0.2",
  "service_ipv6": "2001:db8:1234:5678:9abc:def0:fedc:ba98",
  "profile": "QOS_L",
  "duration": 3300,
  "started_at": "2023-10-27T10:00:00Z",
  "expires_at": "2023-10-27T11:00:00Z"
}
```
```

--------------------------------

### Get Device by Network Access Identifier (NAI)

Source: https://context7.com/context7/networkascode_nokia_io/llms.txt

Identifies a device using its Network Access Identifier, which is typically an email-like format. This method is useful when phone numbers are not available or for specific network configurations.

```python
device = client.devices.get(
    network_access_identifier="user123@operator.net"
)
```

--------------------------------

### Initialize NetworkAsCodeClient in TypeScript

Source: https://networkascode.nokia.io/docs/location/index-loc

Initializes the NetworkAsCodeClient, the entry point for Network as Code functionalities. Requires an application key (token) for authentication.

```typescript
const client = new nac.NetworkAsCodeClient("<your-application-key-here>");
```

--------------------------------

### Get Device Roaming Status - Python

Source: https://networkascode.nokia.io/docs/status/device-roaming

Retrieves the current roaming status of a specific mobile device. This function is called on a pre-configured device object and returns the roaming status, which can be used for various checks.

```python
print(my_device.get_roaming())
```

--------------------------------

### Create Device Object using client.devices.get()

Source: https://networkascode.nokia.io/docs/general-concepts/network-as-code-client

Identifies a specific device associated with the client using the client.devices.get() method. This method accepts various optional parameters such as IPv4 address, IPv6 address, and phone number to uniquely identify a device. At least one parameter is required.

```python
import network_as_code as nac

from network_as_code.models.device import Device, DeviceIpv4Addr

client = nac.NetworkAsCodeClient(
    token="<your-application-key-here>"
)

my_device = client.devices.get(
    "device@testcsp.net",
    ipv4_address=DeviceIpv4Addr(
        public_address="233.252.0.2",
        private_address="192.0.2.25",
        public_port=80
    ),
    ipv6_address="2001:db8:1234:5678:9abc:def0:fedc:ba98",
    # The phone number does not accept spaces or parentheses
    phone_number="+36721601234567"
)
```

```typescript
import network_as_code as nac

from network_as_code.models.device import Device, DeviceIpv4Addr

const client = new nac.NetworkAsCodeClient(
    token="<your-application-key-here>"
);

const myDevice = await client.devices.get(
    "device@testcsp.net",
    {
        ipv4Address: new DeviceIpv4Addr(
            "233.252.0.2",
            "192.0.2.25",
            80
        ),
        ipv6Address: "2001:db8:1234:5678:9abc:def0:fedc:ba98",
        // The phone number does not accept spaces or parentheses
        phoneNumber: "+36721601234567"
    }
);
```

--------------------------------

### Python: Manage Network Slice Life Cycle with SDK

Source: https://networkascode.nokia.io/docs/slicing/slice-life-cycle

Demonstrates how to use the Network as Code Python SDK to create, activate, attach/detach devices, deactivate, and delete a network slice. It utilizes asynchronous methods like `wait_for` and includes fallback for manual polling. Requires network_as_code library and asyncio.

```python
import network_as_code as nac

from network_as_code.models.device import DeviceIpv4Addr

from network_as_code.models.slice import(
    NetworkIdentifier,
    SliceInfo,
)

import asyncio
import time

# We begin by creating a Network as Code client
client = nac.NetworkAsCodeClient(
    token="<your-application-key-here>"
)

# This is the device object we'll later attach to the slice
my_device = client.devices.get(
    "device@testcsp.net",
    ipv4_address=DeviceIpv4Addr(
        public_address="233.252.0.2",
        private_address="192.0.2.25",
        public_port=80
    ),
)

# Then, we create a slice
my_slice = client.slices.create(
    name="slice-name",
    network_id = NetworkIdentifier(mcc="236", mnc="30"),
    slice_info = SliceInfo(service_type="eMBB", differentiator="123456"),
    # Use HTTPS to send notifications
    notification_url="http://notify.me/here",
    notification_auth_token="replace-with-your-auth-token"
)

# Alternatively, you can also get a slice by its ID:
slice = client.slices.get(my_slice.name)

async def slice_attachments():
    # We can take advantage of Slice.wait_for() in async functions
    # This allows us to, e.g., wait for a slice to become available
    await my_slice.wait_for(desired_state="AVAILABLE")

    # Slices must be activated before devices can be added
    my_slice.activate()
    await my_slice.wait_for(desired_state="OPERATING")

    # Afterwards we can attach or detach devices
    device = client.devices.get(my_device)
    my_slice.attach(my_device)
    my_slice.detach(my_device)

    # For deallocating a slice, we first deactivate the slice
    my_slice.deactivate()
    await my_slice.wait_for(desired_state="AVAILABLE")

    # A deactivated slice can be freely removed
    my_slice.delete()

# Since we use the asynchronous Slice.wait_for(), we must execute
# in an async function. We can run such functions with asyncio:
asyncio.run(slice_attachments())

# If you cannot run async functions, you can also utilize webhook
# handlers or polling to handle slice state transitions.
# Simple manual polling can be implemented like this:
while my_slice.state != "AVAILABLE":
    my_slice.refresh()
    time.sleep(1)
```

--------------------------------

### Get Device by IPv4 Address

Source: https://context7.com/context7/networkascode_nokia_io/llms.txt

Retrieves a device using its public and private IPv4 addresses, along with the public port. This method is suitable for identifying devices behind NAT or when IP addresses are the primary identifiers.

```python
from network_as_code.models.device import DeviceIpv4Addr

device = client.devices.get(
    ipv4_address=DeviceIpv4Addr(
        public_address="233.252.0.2",
        private_address="192.0.2.25",
        public_port=80
    )
)
```

--------------------------------

### Set up Web Server for QoD Notifications - Python

Source: https://networkascode.nokia.io/docs/quality-on-demand/qod-notifications-and-life-cycle

This Python code snippet utilizes FastAPI to set up a simple HTTP server with a POST endpoint at '/qod'. This endpoint is designed to receive QoD session event notifications. It includes Pydantic models for structuring the incoming notification data and an authorization check for the incoming request's 'Bearer' token.

```python
import time

from fastapi import FastAPI, Header

from pydantic import BaseModel

from typing_extensions import Annotated
from typing import Union

# Our web server for receiving QoD notifications
app = FastAPI()

class EventDetail(BaseModel):
    sessionId: str
    qosStatus: str
    statusInfo: str

class Event(BaseModel):
    eventType: str
    eventTime: str
    eventDetail: EventDetail

class Notification(BaseModel):
    id: str
    source: str
    type: str
    specversion: str
    datacontenttype: str
    time: str
    event: Event
    data: EventDetail

@app.post("/qod")
def receive_notification(
    notification: Notification,
    authorization: Annotated[Union[str, None], Header]
):
    if authorization == "Bearer my-token":
        # We can now react to the notifications
        # based on the Notification object
        print(notification)

```

--------------------------------

### Get Device by Phone Number

Source: https://context7.com/context7/networkascode_nokia_io/llms.txt

Retrieves a device object using its phone number. This is the most common method for device identification. It's used in various scenarios like SIM swap detection and connectivity testing.

```python
sim_swap_occurred = client.devices.get(phone_number="+99999991000")
sim_swap_not_occurred = client.devices.get(phone_number="+99999991001")

device_connected_sms = client.devices.get(phone_number="+99999991000")
device_connected_data = client.devices.get(phone_number="+99999991001")
device_disconnected = client.devices.get(phone_number="+99999991002")

device_400_error = client.devices.get(phone_number="+99999990400")
device_404_error = client.devices.get(phone_number="+99999990404")

device = client.devices.get(
    phone_number="+36721601234567"
)
```

--------------------------------

### Initialize Network as Code Client (Python, TypeScript)

Source: https://networkascode.nokia.io/docs/status/index-status

Initializes the NetworkAsCodeClient, which serves as the entry point for all Network as Code functionalities. It requires an application key (token) for authentication. This client is essential for interacting with the Network as Code services.

```python
client = nac.NetworkAsCodeClient(token="<your-application-key-here>")
```

```typescript
const client = new NetworkAsCodeClient("<your-application-key-here>");
```

--------------------------------

### Create QoD Session with Specific Ports (Python)

Source: https://networkascode.nokia.io/docs/quality-on-demand/qod-sessions

This Python snippet demonstrates creating a Quality of Service (QoS) session by specifying exact ports for the service and the device, rather than a range. This method, using `PortsSpec` with a list of ports, offers precise control over which ports are utilized for the prioritized session.

```python
from network_as_code.models.session import PortsSpec

my_session = my_device.create_qod_session(
    service_ipv4="233.252.0.2",
    service_ipv6="2001:db8:1234:5678:9abc:def0:fedc:ba98",
    service_ports=PortsSpec(ports=[80, 443]),
    device_ports=PortsSpec(ports=[1600, 2000]),
    profile="QOS_L",
    duration=3600
)

```
Tokens:
Raw