Licensefile Setup and Usage

75min
Licensefile Setup
Key and IV Setup
To use licensefile inside a python SDK you should first setup your key and IV. Key and IV are used inside Python SDK for encryption and decryption process inside licensefile. This process is only required once at the setup.
Python
from licensespring.licensefile.default_crypto import DefaultCryptoProvider

password = "YOUR_PASSWORD"
salt = "YOUR_SALT"


crypto = DefaultCryptoProvider()

key = crypto.derive_key(password=password,salt=salt)
iv = crypto.generate_random_iv()

from licensespring.licensefile.default_crypto import DefaultCryptoProvider

password = "YOUR_PASSWORD"
salt = "YOUR_SALT"


crypto = DefaultCryptoProvider()

key = crypto.derive_key(password=password,salt=salt)
iv = crypto.generate_random_iv()
﻿
Configuration Setup
After you have successfully setup your key and IV you should setup your Configuration. 
Python
from licensespring.licensefile.config import Configuration
#from licensespring.hardware import HardwareIdProviderSource
#The commented hardware_id_provider will become the default in the next major version of the SDK
#we advise using HardwareIdProviderSource!
conf = Configuration(product="your_product_key",api_key="your_api_key",
                   shared_key="your_shared_key",file_key=key,file_iv=iv,
                   is_guard_file_enabled=True,
                   #hardware_id_provider=HardwareIdProviderSource)


                              
from licensespring.licensefile.config import Configuration
#from licensespring.hardware import HardwareIdProviderSource
#The commented hardware_id_provider will become the default in the next major version of the SDK
#we advise using HardwareIdProviderSource!
conf = Configuration(product="your_product_key",api_key="your_api_key",
                   shared_key="your_shared_key",file_key=key,file_iv=iv,
                   is_guard_file_enabled=True,
                   #hardware_id_provider=HardwareIdProviderSource)


                              
﻿
Configuration Attributes
product (str): product short code. 
api_key (str,optional): Your unique API key used for authentication with the licensing server. 
shared_key (str,optional): A shared secret key used alongside the API key for enhanced security during the license verification process.
file_key (str): The encryption key used for securing license files on the client side. 
file_iv (str): The initialization vector for the encryption algorithm. This complements the file_key for encrypting and decrypting license files. 
hardware_id_provider (object, optional): The provider class used for generating a unique hardware ID. This ID helps in binding the license to specific hardware. Defaults to HardwareIdProvider.
verify_license_signature (bool, optional): A boolean flag indicating whether the license's digital signature should be verified. Defaults to True for enhanced security.
signature_verifier (object, optional): The class responsible for verifying the digital signature of licenses. Defaults to SignatureVerifier.
api_domain (str, optional): The domain name of the API server with which the licensing operations are performed. Defaults to "api.licensespring.com".
api_version (str, optional): The version of the API to use for requests. This allows for compatibility with different versions of the licensing API. Defaults to "v4".
filename (str, optional): The default filename for saved license files. This can be customized as needed. Defaults to "License".
file_path (str, optional): The path where license files should be saved on the client system. If not specified, a default location is used.
grace_period_conf (int, optional): The number of hours to allow as a grace period for  Defaults to 24 hours.
is_guard_file_enabled (bool): Enables guard protection for offline licenses if set to True.
air_gap_public_key (str, optional): Air gap public key
client_id (str, optional): Client ID for OAuth authorization purposes
client_secret (str, optional): Client Secret for OAuth authorization purposes
We advise for  hardware_id_provider to use a newly developed  HardwareIdProviderSource﻿  provider.
On the next major version release HardwareIdProviderSource will be set as default hardware_id_provider
if both API keys and OAuth are specified in Configuration, SDK will use OAuth for authorization
LicenseID
Represents a mechanism for license identification and activation, supporting both key-based and user-based activations.
Methods
from_key(cls, key) - Class method to create a LicenseID instance for key-based activation
from_user(cls, username, password) - Class method to create a LicenseID instance for user-based activation.
Key-Based Setup
Python
from licensespring.licensefile.license_manager import LicenseID

license_id = LicenseID.from_key("your_license_key")            
from licensespring.licensefile.license_manager import LicenseID

license_id = LicenseID.from_key("your_license_key")            
﻿
User-Based Setup
Python
from licensespring.licensefile.license_manager import LicenseID

license_id = LicenseID.from_user(username="[email protected]",password="password")                         
from licensespring.licensefile.license_manager import LicenseID

license_id = LicenseID.from_user(username="email@email.com",password="password")                         
﻿
LicenseManager
Manages license activations, supporting a variety of parameters to accommodate different licensing scenarios.
Python

from licensespring.licensefile.license_manager import LicenseManager

manager = LicenseManager(conf)
                                

from licensespring.licensefile.license_manager import LicenseManager

manager = LicenseManager(conf)
                                
﻿
Configuration parametres
conf (Configuration): A configuration object
Methods
Getters
Python
manager.is_license_file_corrupted() # Checks if licensefile is corrupted 
manager.data_location() # Get licensefile location 
manager.license_file_name() # Get licensefile name  
manager.current_config() # Get current configuration                   
manager.is_license_file_corrupted() # Checks if licensefile is corrupted 
manager.data_location() # Get licensefile location 
manager.license_file_name() # Get licensefile name  
manager.current_config() # Get current configuration                   
﻿
activate_license
Activates a license with the license server and updates local license data.Returns an instance of the License
Key-based
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H6QM-6H5R-ZENJ-VBLK")

license = manager.activate_license(license_id)
                                
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H6QM-6H5R-ZENJ-VBLK")

license = manager.activate_license(license_id)
                                
﻿
User-based 
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_user(username="[email protected]",password="7t_x3!o9")

license = manager.activate_license(license_id,unique_license_id=1723642193958949)
                          
manager = LicenseManager(conf)

license_id = LicenseID.from_user(username="python@gmail.com",password="7t_x3!o9")

license = manager.activate_license(license_id,unique_license_id=1723642193958949)
                          
﻿
There is optional unique_license_id which specifies license_id. It if prefered that given argument is used when activating user based licenses
load_license
Loads the license file and sets attributes for the LicenseData instance. Returns an instance of the License class reflecting the loaded license.
Python
manager = LicenseManager(conf)

license = manager.load_license()

                                
manager = LicenseManager(conf)

license = manager.load_license()

                                
﻿
﻿
reconfigure
Change the current configuration
Python
manager = LicenseManager(conf)

manager.reconfigure(
        Configuration(
            product="lkprod2",
            api_key="new_key",
            shared_key="new_key",
            file_key="file_key",
            file_iv="file_iv",
            file_path="bb",
            grace_period_conf=12,
            is_guard_file_enabled=True,
        )
    )

                                
manager = LicenseManager(conf)

manager.reconfigure(
        Configuration(
            product="lkprod2",
            api_key="new_key",
            shared_key="new_key",
            file_key="file_key",
            file_iv="file_iv",
            file_path="bb",
            grace_period_conf=12,
            is_guard_file_enabled=True,
        )
    )

                                
﻿
clear_local_storage
Delete all files for given product
Python
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H6QM-6H5R-ZENJ-VBLK")  
license = manager.activate_license(license_id)  
manager.clear_local_storage()

                                
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H6QM-6H5R-ZENJ-VBLK")  
license = manager.activate_license(license_id)  
manager.clear_local_storage()

                                
﻿
set_data_location
Set data location
Parameters:
path (str): new data location path
Python
manager = LicenseManager(conf)
manager.set_data_location()
manager = LicenseManager(conf)
manager.set_data_location()
﻿
Return: None
set_license_file_name
Set licensefile name
Parameters:
name (str): license file name
Python
manager = LicenseManager(conf)
manager.set_license_file_name()
manager = LicenseManager(conf)
manager.set_license_file_name()
﻿
Return: None
is_online
Checks if the licensing server is accessible. 
Parameters:
throw_e: (bool,optional): If True throws exception, otherwise exception won't be raised.  
Python
manager = LicenseManager(conf)

license = manager.is_online()                   
manager = LicenseManager(conf)

license = manager.is_online()                   
﻿
Returns: True if online, False otherwise.
create_offline_activation_file
Creates request file for offline activation.
Parameters:
license_id(LicenseID):
req_path(str): path where .req file is created
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H94R-S6KB-L7AJ-SXLK")

req_file_path = manager.create_offline_activation_file(license_id,'offline_files/test')
                                
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H94R-S6KB-L7AJ-SXLK")

req_file_path = manager.create_offline_activation_file(license_id,'offline_files/test')
                                
﻿
Returns(str): path to request file 
activate_license_offline
Activates the .lic file
Parameters:
ls_activation_path(str): path to .lic file 
Python
manager = LicenseManager(conf)

license = manager.activate_license_offline('path_to_lic_file/ls_activation.lic')
                                
manager = LicenseManager(conf)

license = manager.activate_license_offline('path_to_lic_file/ls_activation.lic')
                                
﻿
Raises:
LicenseActivationException: Activation data is not valid
LicenseActivationException: Response file ID mismatch
LicenseActivationException: License does not belong to this device
Returns (License): License object 
get_air_gap_activation_code
Get activation code for air gap license
Parameters:
initialization_code (str): initialization code
license_key (str): license key
Python
initialization_code = "Q/MWfwp1NWAYARl8Q7KSo5Cg2YKqS2QLlnQ3nEeSBsk="
license_key = "UFF3-E9GA-VUJQ-GMLK"

manager = LicenseManager(conf)
activation_code = manager.get_air_gap_activation_code(initialization_code=initialization_code, license_key=license_key)

print("Activation code:",activation_code)
initialization_code = "Q/MWfwp1NWAYARl8Q7KSo5Cg2YKqS2QLlnQ3nEeSBsk="
license_key = "UFF3-E9GA-VUJQ-GMLK"

manager = LicenseManager(conf)
activation_code = manager.get_air_gap_activation_code(initialization_code=initialization_code, license_key=license_key)

print("Activation code:",activation_code)
﻿
Return (str): activation code
activate_air_gap_license
Activates air gap license
Parameters:
confirmation_code (str): confirmation code
policy_path (str): policy path (file or folder)
license_key (str): license_key
policy_id (str): policy id
Python
confirmation = "ERbQBuE8giIjqMPj972Skipehqn0szQ8TH56INyo3OdtMHO1SuTVsoCOSnJWB6rml98PJ6SjybTPymOVZTG4hQ=="
policy_id = "998"
license_key = "UFF3-E9GA-VUJQ-GMLK"
policy_path = "path_to_air_lic"

manager = LicenseManager(conf)
license = manager.activate_air_gap_license(
                confirmation_code=confirmation, policy_path=policy_path, license_key=license_key, policy_id=policy_id
            )
confirmation = "ERbQBuE8giIjqMPj972Skipehqn0szQ8TH56INyo3OdtMHO1SuTVsoCOSnJWB6rml98PJ6SjybTPymOVZTG4hQ=="
policy_id = "998"
license_key = "UFF3-E9GA-VUJQ-GMLK"
policy_path = "path_to_air_lic"

manager = LicenseManager(conf)
license = manager.activate_air_gap_license(
                confirmation_code=confirmation, policy_path=policy_path, license_key=license_key, policy_id=policy_id
            )
﻿
Raises:
LicenseActivationException: Signature verification failed
Return (License): License
get_trial_license
Creates LiceseID for trial licenses
Parameters:
customer (Customer): Customer object
license_policy(str,optional): icense policy code. Defaults to None.
Python
customer = Customer(email='[email protected]')  

manager = LicenseManager(conf)

license_id = manager.get_trial_license(customer=customer,license_policy='test')
    
license = manager.activate_license(license_id=license_id)
customer = Customer(email='python_policy@gmail.com')  

manager = LicenseManager(conf)

license_id = manager.get_trial_license(customer=customer,license_policy='test')
    
license = manager.activate_license(license_id=license_id)
﻿
Return(LicenseID): Returns a LicenseID object.
get_version_list
Get versions
Parameters:
license_id (LicenseID): license id object
bundle_code (str,optional): specify unique bundle_code of a bundle
unique_license_id (int,optional): A unique identifier for the license.
env (str,optional): Version of environment
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("3ZG2-K25B-76VN-WXLK")

response = manager.get_version_list(license_id=license_id)
manager = LicenseManager(conf)

license_id = LicenseID.from_key("3ZG2-K25B-76VN-WXLK")

response = manager.get_version_list(license_id=license_id)
﻿
Return(list): List of versions
get_installation_file
Get installation file
Parameters:
license_id (LicenseID): An instance containing the license key or user credentials
bundle_code (str, optional): specify unique bundle_code of a bundle
unique_license_id (int, optional): A unique identifier for the license.
env (str, optional): Version of environment
version (str, optional): Versions
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("3ZG2-K25B-76VN-WXLK")

response = manager.get_installation_file(license_id=license_id)
manager = LicenseManager(conf)

license_id = LicenseID.from_key("3ZG2-K25B-76VN-WXLK")

response = manager.get_installation_file(license_id=license_id)
﻿
Return (dict): installation file
get_customer_license_users
Get customer license users
Parameters:
customer (Customer): customer
Python
manager = LicenseManager(conf)

customer = Customer(email="[email protected]")

response = manager.get_customer_license_users(customer=customer)
manager = LicenseManager(conf)

customer = Customer(email="c1@c.com")

response = manager.get_customer_license_users(customer=customer)
﻿
Return(dict): customer license user
get_user_licenses
Get user licenses
Parameters:
license_id (LicenseID): license_id
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_user(username="[email protected]", password="d#2!17vi")

response = manager.get_user_licenses(license_id)
manager = LicenseManager(conf)

license_id = LicenseID.from_user(username="t@tt.com", password="d#2!17vi")

response = manager.get_user_licenses(license_id)
﻿
Return(list): User licenses
get_sso_url
Parameters:
account_code (str): account code
use_auth_code (bool, optional): Use code for response_type. Defaults to True.
Python
manager = LicenseManager(conf)

response = manager.get_sso_url(account_code="your_account_code")
manager = LicenseManager(conf)

response = manager.get_sso_url(account_code="your_account_code")
﻿
Return(dict): url
License
Object responsible for license operations
Methods
Getters
All getters which are reading the license fields from a local licensefile
Python
# Floating 
license.is_floating_expired() # Determines wheter the license floating period has expired
license.floating_timeout() # License floating timeout
license.is_floating() # True if license if floating, otherwise False
license.floating_client_id() # Floating client id 
license.is_controlled_by_floating_server() # Check if license is controlled by Floating Server 
license.floating_in_use_devices() # Number of floating devices in use 
license.floating_end_date() # Datetime when device will be released
license.max_floating_users() # Number of max floating users
license.expiry_date() # Get the expiry date of a floating license
license.borrow_until() # Get the date until a license is borrwed
license.is_borrowed() # Check if a license is borrowed

# time-limited
license.is_validity_period_expired() # Determines whether the license's validity period has expired
license.validity_period() # Gets the license validity period in UTC
license.validity_with_grace_period() # Gets the validity period with grace period of the license in UTC
license.days_remaining() # Gets how many days are left until the validity period ends
license.is_expired() # Checks if a license validity has expired

# consumption
license.local_consumptions() # Get local consumptions
license.max_consumptions() # Get max consumptions
license.total_consumptions() # Get total consumptions
license.max_overages() # Get max overages
license.allow_unlimited_consumptions() # Check if unlimited consumptions are allowed
license.consumption_reset() # Check if there is consumption reset
license.allow_overages() # Check if overages are allowed

# subscription 
license.allow_grace_subscription_period() # Check if grace subscription period is allowed
license.is_subscription_grace_period_started() # Check if grace subscription period has started
license.get_grace_period() # Get grace period
license.subscription_grace_period() # Get subscription grace period

# all 
 license.license_user() # Gets the license user
 license.is_grace_period_started() # Checks if grace period has started
 license.grace_period_hours_remaining() # Get remain hours of grace period
 license.maintenance_days_remaining() # Gets how many days are left until the maintenance ends
 license.customer_information() # Gets customer information
 license.id() # Gets a license id
 license.max_transfers() # Get a license max transfers
 license.transfer_count() # Get the transfer count
 license.is_device_transfer_allowed() # Get if a device transfer is allowed
 license.is_device_transfer_limited() # Get if a device transfer is limited
 license.days_since_last_check() # Get how many days passed since the last check
 license.start_date() # Get a license start date in UTC
 license.maintenance_period() # Get a license maintenance period in UTC
 license.is_maintence_period_expired() # Checks if maintence period has expired
 license.last_check() # Get when last check was performed in UTC
 license.last_usage() # Gets a license last usage in UTC
 license.license_type() # Gets the last license usage
 license.max_activations() # Gets the license max activations
 license.metadata() # Gets the license metadata
 license.allow_unlimited_activations() # Check if unlimited activations are allowed
 license.license_enabled() # Checks if a license is enabled
 license.license_active() # Checks if a license is active
 license.is_valid() # Checks if the license is valid (license is active, enabled and didn't expired)
 license.prevent_vm() # Checks if a license prevents virtual machines
 license.is_trial() # Checks if a license is trial
 license.get_product_details() # Get product details
 license.get_device_variable('device_var') # Get device variable if exists
 
 # features
 license.get_feature_data(feature_code) # Get feature data
 
# Floating 
license.is_floating_expired() # Determines wheter the license floating period has expired
license.floating_timeout() # License floating timeout
license.is_floating() # True if license if floating, otherwise False
license.floating_client_id() # Floating client id 
license.is_controlled_by_floating_server() # Check if license is controlled by Floating Server 
license.floating_in_use_devices() # Number of floating devices in use 
license.floating_end_date() # Datetime when device will be released
license.max_floating_users() # Number of max floating users
license.expiry_date() # Get the expiry date of a floating license
license.borrow_until() # Get the date until a license is borrwed
license.is_borrowed() # Check if a license is borrowed

# time-limited
license.is_validity_period_expired() # Determines whether the license's validity period has expired
license.validity_period() # Gets the license validity period in UTC
license.validity_with_grace_period() # Gets the validity period with grace period of the license in UTC
license.days_remaining() # Gets how many days are left until the validity period ends
license.is_expired() # Checks if a license validity has expired

# consumption
license.local_consumptions() # Get local consumptions
license.max_consumptions() # Get max consumptions
license.total_consumptions() # Get total consumptions
license.max_overages() # Get max overages
license.allow_unlimited_consumptions() # Check if unlimited consumptions are allowed
license.consumption_reset() # Check if there is consumption reset
license.allow_overages() # Check if overages are allowed

# subscription 
license.allow_grace_subscription_period() # Check if grace subscription period is allowed
license.is_subscription_grace_period_started() # Check if grace subscription period has started
license.get_grace_period() # Get grace period
license.subscription_grace_period() # Get subscription grace period

# all 
 license.license_user() # Gets the license user
 license.is_grace_period_started() # Checks if grace period has started
 license.grace_period_hours_remaining() # Get remain hours of grace period
 license.maintenance_days_remaining() # Gets how many days are left until the maintenance ends
 license.customer_information() # Gets customer information
 license.id() # Gets a license id
 license.max_transfers() # Get a license max transfers
 license.transfer_count() # Get the transfer count
 license.is_device_transfer_allowed() # Get if a device transfer is allowed
 license.is_device_transfer_limited() # Get if a device transfer is limited
 license.days_since_last_check() # Get how many days passed since the last check
 license.start_date() # Get a license start date in UTC
 license.maintenance_period() # Get a license maintenance period in UTC
 license.is_maintence_period_expired() # Checks if maintence period has expired
 license.last_check() # Get when last check was performed in UTC
 license.last_usage() # Gets a license last usage in UTC
 license.license_type() # Gets the last license usage
 license.max_activations() # Gets the license max activations
 license.metadata() # Gets the license metadata
 license.allow_unlimited_activations() # Check if unlimited activations are allowed
 license.license_enabled() # Checks if a license is enabled
 license.license_active() # Checks if a license is active
 license.is_valid() # Checks if the license is valid (license is active, enabled and didn't expired)
 license.prevent_vm() # Checks if a license prevents virtual machines
 license.is_trial() # Checks if a license is trial
 license.get_product_details() # Get product details
 license.get_device_variable('device_var') # Get device variable if exists
 
 # features
 license.get_feature_data(feature_code) # Get feature data
 
﻿
check_license_status
Verifies the current status of the license. It raises exceptions if the license is not enabled, not active, or expired
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)
    
license.check_license_status()

                                
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)
    
license.check_license_status()

                                
﻿
Raises:
LicenseStateException: Raised if the license fails one of the following checks:
License is not enabled.
License is not active.
License validity period has expired.
Return: None
check
Performs an online check to synchronize the license data with the backend. This includes syncing consumptions for consumption-based licenses.
Parameters:
include_expired_features (bool, optional): Includes expired license features in the check.
env (str, optional): "win", "win32", "win64", "mac", "linux", "linux32" or "linux64"
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)
    
response = license.check()

                                
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)
    
response = license.check()

                                
﻿
Raises:
ClientError: Raised if there's an issue with the API client's request, such as invalid credentials or unauthorized access.
RequestException: Raised if there's a problem with the request to the licensing server, such as network issues or server unavailability.
Return (dict): The updated license cache.
deactivate
Deactivates the license and optionally deletes the local license file.
Parameters:
delete_license (bool, optional): If True, deletes the local license file upon deactivation.
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)
    
license.deactivate()

                                
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)
    
license.deactivate()

                                
﻿
Return: None
local_check
This method ensures the integrity and consistency of the licensing information by comparing the data stored in the local license file with the predefined configurations in the Configuration object.
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)
    
license.local_check()

                                
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)
    
license.local_check()

                                
﻿
Raises:
ConfigurationMismatch: Raised if the product code or hardware ID in the license file does not match the expected values provided in the Configuration
VMIsNotAllowedException: Raised if the license is used in a VM environment when the license explicitly disallows it.
TimeoutExpiredException: Raised if a floating license has expired. This is more relevant if is_floating_expired is later implemented to perform actual checks.
ClockTamperedException: Raised if there is evidence of tampering with the system's clock, detected by comparing the system's current time with the last usage time recorded in the license file.
Return: None
add_local_consumption
Adds local consumption records for consumption-based licenses.
Parameters:
consumptions (int, optional): The number of consumptions to add locally.
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)
    
license.add_local_consumption()

                                
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)
    
license.add_local_consumption()

                                
﻿
Raises:
LicenseSpringTypeError: Raised if the license type does not support consumption (i.e., not a consumption-based license).
ConsumptionError: Raised if adding the specified number of consumptions would exceed the allowed maximum for the license.
Return: None
sync_consumption
Synchronizes local consumption data with the server, adjusting for overages if specified.
Parameters:
req_overages (int, optional): Specifies behavior for consumption overages.
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)

license.add_local_consumption(5)
    
license.sync_consumption()

                                
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)

license.add_local_consumption(5)
    
license.sync_consumption()

                                
﻿
Raises:
RequestException: Raised if the request to synchronize consumption data with the server fails, for instance, due to network issues or server unavailability.
Return (bool): True if the consumption data was successfully synchronized; False otherwise.
is_grace_period
Determines if the current license state is within its grace period following a specific exception.
Parameters:
ex (Exception): Raised Exception
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)

try:
    license.check()

except Exception as ex
    boolean = license.is_grace_period(ex)    

                    
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)

try:
    license.check()

except Exception as ex
    boolean = license.is_grace_period(ex)    

                    
﻿
Return (bool): True if the license is within its grace period, False otherwise
change_password
Changes password of a user
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_user(username="[email protected]",password="7t_x3!o9")

license = manager.activate_license(license_id)

license.change_password("7t_x3!o9","12345678")
    


                                
manager = LicenseManager(conf)

license_id = LicenseID.from_user(username="python@gmail.com",password="7t_x3!o9")

license = manager.activate_license(license_id)

license.change_password("7t_x3!o9","12345678")
    


                                
﻿
Return (str): "password_changed"
add_local_feature_consumption
Adds local consumption to the feature.
Parameters:
feature (str): feature code.
consumptions (int,optional): Number of consumptions.
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)

license.add_local_feature_consumption("lkprod1cf1",3)                                
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)

license.add_local_feature_consumption("lkprod1cf1",3)                                
﻿
Raises:
ItemNotFoundError: If the feature specified by `feature_code` does not exist.
LicenseSpringTypeError: If the identified feature is not of the "consumption" type.
ConsumptionError: If adding the specified number of consumptions would exceed the feature's consumption limits.
Return: None
sync_feature_consumption
Synchronizes local consumption data with the server.
Parameters:
feature (str): feature code.
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)

license.add_local_feature_consumption("lkprod1cf1",3)

license.sync_feature_consumption("lkprod1cf1")
                                
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)

license.add_local_feature_consumption("lkprod1cf1",3)

license.sync_feature_consumption("lkprod1cf1")
                                
﻿
Raises:
RequestException: Raised if the request to synchronize consumption data with the server fails, for instance, due to network issues or server unavailability.
Return (bool): True if the consumption data was successfully synchronized; False otherwise.
floating_borrow
Attempts to borrow a floating license until the specified date.
Parameters:
borrow_until(str): A string representing the date until which the license should be borrowed.
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)

license.floating_borrow("2031-05-06T00:00:00Z")

                                
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)

license.floating_borrow("2031-05-06T00:00:00Z")

                                
﻿
Return: None
floating_release
Releases a borrowed floating license and updates the license status accordingly.
Parameters:
throw_e(bool): A boolean indicating whether to raise an exception on failure.
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)

license.check()

license.floating_release(False)

                                
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)

license.check()

license.floating_release(False)

                                
﻿
Raises:
Exception
Return: None
check_feature
Checks for a specific license feature and updates the license cache accordingly.
Parameters:
feature(str): feature code.
add_to_watchdog (bool,optional): A boolean indicating whether to add the feature check to a watchdog routine. Default is False
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)

license.check_feature("lkprod1f1fc1") 

                                
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)

license.check_feature("lkprod1f1fc1") 

                                
﻿
Raises:
Exception
Return: None
release_feature
Releases a borrowed license feature and updates the license cache accordingly.
Parameters:
feature(str): feature code.
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)

license.check_feature("lkprod1f1fc1")

license.release_feature("lkprod1f1fc1")                      
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")

license = manager.activate_license(license_id)

license.check_feature("lkprod1f1fc1")

license.release_feature("lkprod1f1fc1")                      
﻿
Raises:
Exception
Return: None
update_offline
Updates license via refresh file
Parameters:
path (str): path of the refresh file
reset_consumption (bool): True resets consumption otherwise False
Python
file_path = 'path_to_lic_file/license.lic'

manager = create_manager(product="lkprod1",is_guard_file_enabled=True)

license = manager.activate_license_offline(file_path)

license.update_offline('offline_files/license_refresh.lic',False)                   
file_path = 'path_to_lic_file/license.lic'

manager = create_manager(product="lkprod1",is_guard_file_enabled=True)

license = manager.activate_license_offline(file_path)

license.update_offline('offline_files/license_refresh.lic',False)                   
﻿
Raises:
ConfigurationMismatch: The update file does not belong to this device
ConfigurationMismatch: The update file does not belong to this product
Return (bool): True if license was successfully updated otherwise False
deactivate_offline
Generates .req file for the offline deactivation
Parameters:
offline_path (str): path of the .req file
Python
file_path = 'path_to_lic_file/license.lic'

manager = create_manager(product="lkprod1",is_guard_file_enabled=True)

license = manager.activate_license_offline(file_path)

license.deactivate_offline('path_where_to_create_req_file')

                                
file_path = 'path_to_lic_file/license.lic'

manager = create_manager(product="lkprod1",is_guard_file_enabled=True)

license = manager.activate_license_offline(file_path)

license.deactivate_offline('path_where_to_create_req_file')

                                
﻿
Return (str): path of the deactivation file
get_deactivation_code
Get deactivation code for air gap licenses
Parameters:
initialization_code (str): initialization_code
Python
initialization_code="your_initialization_code"
manager = LicenseManager(conf)
#load air gap license
license = manager.load_license()

deactivation_code = license.get_deactivation_code(initialization_code)

print("Deactivation code:",deactivation_code)
                                
initialization_code="your_initialization_code"
manager = LicenseManager(conf)
#load air gap license
license = manager.load_license()

deactivation_code = license.get_deactivation_code(initialization_code)

print("Deactivation code:",deactivation_code)
                                
﻿
Return (str): deactivation code
deactivate_air_gap
Deactivate air gap license and clear storage
Parameters:
confirmation_code (str): confirmation_code
Python
confirmation_code="your_confirmation_code"
manager = LicenseManager(conf)
#load air gap license
license = manager.load_license()
license.deactivate_air_gap(confirmation_code)
                                
confirmation_code="your_confirmation_code"
manager = LicenseManager(conf)
#load air gap license
license = manager.load_license()
license.deactivate_air_gap(confirmation_code)
                                
﻿
Raises:
LicenseActivationException: VerificationError
Return: None
product_details
Update product details from LicenseSpring server
Parameters:
include_custom_fields(bool, optional): custom fields information. Defaults to False.
include_latest_version(bool, optional): Lateset version information. Defaults to False.
env (str, optional): "win", "win32", "win64", "mac", "linux", "linux32" or "linux64"
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H9V3-72XX-ZRAJ-S6LK")

license = manager.activate_license(license_id)
    
response = license.product_details() 
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H9V3-72XX-ZRAJ-S6LK")

license = manager.activate_license(license_id)
    
response = license.product_details() 
﻿
Return(dict): response
set_device_variables
Set device variables locally
Parameters:
variables(dict): variables dict
save(bool, optional): Save cache to licensefile. Defaults to True.
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H9V3-72XX-ZRAJ-S6LK")

license = manager.activate_license(license_id)
    
license.set_device_variables({"english":"value"}) 
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H9V3-72XX-ZRAJ-S6LK")

license = manager.activate_license(license_id)
    
license.set_device_variables({"english":"value"}) 
﻿
Return: None
get_device_variables
Get device variables from server or locally
Parameters:
get_from_be(bool, optional): If True collects data from LicenseSpring server. Defaults to True.
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H9V3-72XX-ZRAJ-S6LK")

license = manager.activate_license(license_id)
    
device_var_list = license.get_device_variables(get_from_be=True)  

print(device_var_list)
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H9V3-72XX-ZRAJ-S6LK")

license = manager.activate_license(license_id)
    
device_var_list = license.get_device_variables(get_from_be=True)  

print(device_var_list)
﻿
Return(list): List of device variables
send_device_variables
Send device variables to LicenseSpring server. Handles GracePeriod
Parameters:
variables(dict): variables dict
save(bool, optional): Save cache to licensefile. Defaults to True.
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H9V3-72XX-ZRAJ-S6LK")

license = manager.activate_license(license_id)
    
license.send_device_variables() 
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H9V3-72XX-ZRAJ-S6LK")

license = manager.activate_license(license_id)
    
license.send_device_variables() 
﻿
Return(bool): True if new variables are sent to LicenseSpring server otherwise, False
custom_fields
Get custom fields from licensefile
Python
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H9V3-72XX-ZRAJ-S6LK")

license = manager.activate_license(license_id)
    
response = license.custom_fields()
manager = LicenseManager(conf)

license_id = LicenseID.from_key("H9V3-72XX-ZRAJ-S6LK")

license = manager.activate_license(license_id)
    
response = license.custom_fields()
﻿
Return(list): Custom fields
API Client Usage Examples
Python Hardware (Device) IDs