The LicenseSpring Python Library provides convenient access to the LicenseSpring API from applications written in the Python language.
Install licensespring library:
pip install licensespring
Requires: Python >=3.7
This library provides preconfigured hardware identity providers:
HardwareIdProvider (default)PlatformIdProviderYou can set the desired hardware identity provider when initializing the APIClient:
from licensespring.hardware import PlatformIdProvider
api_client = APIClient(api_key="_your_api_key_", shared_key="_your_shared_key_", hardware_id_provider=PlatformIdProvider)
It also supports their customization and creation of your own hardware id provider.
Uses uuid.getnode() to generate unique ID per device as described:
Get the hardware address as a 48-bit positive integer. The first time this runs, it may launch a separate program, which could be quite slow. If all attempts to obtain the hardware address fail, we choose a random 48-bit number with the multicast bit (least significant bit of the first octet) set to 1 as recommended in RFC 4122. “Hardware address” means the MAC address of a network interface. On a machine with multiple network interfaces, universally administered MAC addresses (i.e. where the second least significant bit of the first octet is unset) will be preferred over locally administered MAC addresses, but with no other ordering guarantees.
All of the methods exposed by HardwareIdProvider:
class HardwareIdProvider:
def get_id(self):
return str(uuid.getnode())
def get_os_ver(self):
return platform.platform()
def get_hostname(self):
return platform.node()
def get_ip(self):
return socket.gethostbyname(self.get_hostname())
def get_is_vm(self):
return False
def get_vm_info(self):
return None
def get_mac_address(self):
return ":".join(("%012X" % uuid.getnode())[i : i + 2] for i in range(0, 12, 2))
def get_request_id(self):
return str(uuid.uuid4())
Uses sys.platform and OS queries to find the raw GUID of the device.
Extends the HardwareIdProvider and overwrites only the get_id method:
class PlatformIdProvider(HardwareIdProvider):
def get_id(self):
id = None
if sys.platform == 'darwin':
id = execute("ioreg -d2 -c IOPlatformExpertDevice | awk -F\\\" '/IOPlatformUUID/{print $(NF-1)}'")
if sys.platform == 'win32' or sys.platform == 'cygwin' or sys.platform == 'msys':
id = read_win_registry('HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography', 'MachineGuid')
if not id:
id = execute('wmic csproduct get uuid').split('\n')[2].strip()
if sys.platform.startswith('linux'):
id = read_file('/var/lib/dbus/machine-id')
if not id:
id = read_file('/etc/machine-id')
if sys.platform.startswith('openbsd') or sys.platform.startswith('freebsd'):
id = read_file('/etc/hostid')
if not id:
id = execute('kenv -q smbios.system.uuid')
if not id:
id = super().get_id()
return id
Extend any of the preconfigured hardware identity providers, overwrite the methods you want and provide it when initializing the APIClient:
class CustomHardwareIdProvider(HardwareIdProvider):
def get_id(self):
return "_my_id_"
api_client = APIClient(api_key="_your_api_key_", shared_key="_your_shared_key_", hardware_id_provider=CustomHardwareIdProvider)
import licensespring
licensespring.app_version = "MyApp 1.0.0"
from licensespring.api import APIClient
api_client = APIClient(api_key="_your_api_key_", shared_key="_your_shared_key_")
product = "lkprod1"
license_key = "GPB7-279T-6MNK-CQLK"
license_data = api_client.activate_license(product=product, license_key=license_key)
print(license_data)
product = "uprod1"
username = "user1@email.com"
password = "nq64k1!@"
license_data = api_client.activate_license(
product=product, username=username, password=password
)
print(license_data)
product = "lkprod1"
license_key = "GPUB-J4PH-CGNK-C7LK"
api_client.deactivate_license(product=product, license_key=license_key)
product = "uprod1"
username = "user1@email.com"
api_client.deactivate_license(
product=product, username=username
)
product = "lkprod1"
license_key = "GPBQ-DZCP-E9SK-CQLK"
license_data = api_client.check_license(product=product, license_key=license_key)
print(license_data)
product = "uprod1"
username = "user2@email.com"
password = "1l48y#!b"
license_data = api_client.check_license(product=product, username=username)
print(license_data)
product = "lkprod1"
license_key = "GPSU-QTKQ-HSSK-C9LK"
# Add 1 consumption
consumption_data = api_client.add_consumption(
product=product, license_key=license_key
)
print(consumption_data)
# Add 3 consumptions
consumption_data = api_client.add_consumption(
product=product, license_key=license_key, consumptions=3
)
print(consumption_data)
# Add 1 consumption, allow overages and define max overages
consumption_data = api_client.add_consumption(
product=product, license_key=license_key, allow_overages=True, max_overages=10
)
print(consumption_data)
product = "lkprod1"
license_key = "GPTJ-LSYZ-USEK-C8LK"
feature = "lkprod1cf1"
# Add 1 consumption
feature_consumption_data = api_client.add_feature_consumption(
product=product, license_key=license_key, feature=feature
)
# Add 3 consumptions
feature_consumption_data = api_client.add_feature_consumption(
product=product, license_key=license_key, feature=feature, consumptions=3
)
print(feature_consumption_data)
product = "lkprod2"
trial_license_data = api_client.trial_key(product=product)
print(trial_license_data)
product = "lkprod1"
product_data = api_client.product_details(product=product)
print(product_data)
product = "lkprod1"
license_key = "GPUB-SZF9-AB2K-C7LK"
variables = {"variable_1_key": "variable_1_value", "variable_2_key": "variable_2_value"}
device_variables = api_client.track_device_variables(product=product, license_key=license_key, variables=variables)
print(device_variables)
product = "lkprod1"
license_key = "GPUB-SZF9-AB2K-C7LK"
device_variables = api_client.get_device_variables(product=product, license_key=license_key)
print(device_variables)
product = "lkprod1"
license_key = "GPUC-NGWU-3NJK-C7LK"
# Borrow for 2 hours
borrowed_until = (datetime.utcnow() + timedelta(hours=2)).isoformat()
floating_borrow_data = api_client.floating_borrow(product=product, license_key=license_key, borrowed_until=borrowed_until)
print(floating_borrow_data)
product = "lkprod1"
license_key = "GPUC-NGWU-3NJK-C7LK"
api_client.floating_release(product=product, license_key=license_key)
username = "user4@email.com"
password = "_old_password_"
new_password = "_new_password_"
is_password_changed = api_client.change_password(username=username, password=password, new_password=new_password)
print(is_password_changed)
product = "lkprod1"
license_key = "GPB7-279T-6MNK-CQLK"
# Get versions for all environments
versions_data = api_client.versions(product=product, license_key=license_key)
# Get versions for mac environment
mac_versions_data = api_client.versions(
product=product, license_key=license_key, env="mac"
)
print(versions_data)
product = "lkprod1"
license_key = "GPB7-279T-6MNK-CQLK"
# Get the latest installation file
installation_file_data = api_client.installation_file(
product=product, license_key=license_key
)
# Get the latest installation file for linux environment
installation_file_data = api_client.installation_file(
product=product, license_key=license_key, env="linux"
)
# Get the latest installation file for version 1.0.0
installation_file_data = api_client.installation_file(
product=product, license_key=license_key, version="1.0.0"
)
print(installation_file_data)
product = "uprod1"
customer = 'c1@c.com'
customer_license_users_data = api_client.customer_license_users(
product=product, customer=customer
)
print(customer_license_users_data)
product = "uprod1"
customer_account_code = "ccorp"
sso_url_data = api_client.sso_url(
product=product, customer_account_code=customer_account_code
)
print(sso_url_data)
code response typeproduct = "uprod1"
customer_account_code = "ccorp"
sso_url_data = api_client.sso_url(
product=product,
customer_account_code=customer_account_code,
response_type="code",
)
print(sso_url_data)
product = "lkprod1"
license_key = "GPY7-VHX9-MDSK-C3LK"
# Generate data for offline activation
activate_offline_data = api_client.activate_offline_dump(
product=product, license_key=license_key
)
# Write to file
with open('activate_offline.req', mode='w') as f:
print(activate_offline_data, file=f)
# Activate offline
license_data = api_client.activate_offline(data=activate_offline_data)
print(license_data)
# Read from file
with open('./ls_activation.lic') as file:
ls_activation_data = file.read()
license_data = api_client.activate_offline_load(ls_activation_data)
print(license_data)
# Read from file
with open('./license_refresh.lic') as file:
license_refresh_data = file.read()
license_data = api_client.check_offline_load(license_refresh_data)
print(license_data)
product = "lkprod1"
license_key = "GPYC-X5J2-L5SK-C3LK"
# Generate data for offline deactivation
deactivate_offline_data = api_client.deactivate_offline_dump(
product=product, license_key=license_key
)
# Write to file
with open('deactivate_offline.req', mode='w') as f:
print(deactivate_offline_data, file=f)
# Deactivate offline
api_client.deactivate_offline(data=deactivate_offline_data)
product = "lkprod1"
license_key = "GPB7-279T-6MNK-CQLK"
feature = "lkprod1f1"
license_feature_data = api_client.check_license_feature(
product=product, feature=feature, license_key=license_key
)
print(license_feature_data)
product = "lkprod1"
license_key = "GPB7-279T-6MNK-CQLK"
feature = "lkprod1f1"
api_client.floating_feature_release(
product=product, feature=feature, license_key=license_key
)
product = "userpr1"
username = "user123"
password = "password"
response = api_client.user_licenses(
product=product,username=username,
password=password)
print(response)
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. For the first setup it is essenital to chose password and salt for key generation. This process is only required once at the setup.
from licensespring.licensefile.default_crypto import DefaultCryptoProvider
password = "YOUR_PASSWORD"
salt = "YOUR_SALT"
crypto = DefaultCryptoProvider()
key = crypto.derive_key(password=key_password,salt=key_salt)
iv = crypto.generate_random_iv()
After you have successfully setup your key and IV you should setup your Configuration.
from licensespring.licensefile.config import Configuration
conf = Configuration(product="your_product_short_code",
api_key="your_api_key",
shared_key="your_shared_key",
file_key=key,
file_iv=iv,
hardware_id_provider=HardwareIdProvider,
verify_license_signature=True,
signature_verifier=SignatureVerifier,
api_domain="api.licensespring.com",
api_version="v4",
filename="License",
file_path=None,
grace_period_conf=24,
air_gap_public_key="your_air_gap_public_key")
license_id = LicenseID.from_key("your_license_key")
license_id = LicenseID.from_user(username="email@email.com",password="password")
from licensespring.licensefile.license_manager import LicenseManager,LicenseID
manager = LicenseManager(conf)
conf (Configuration): A configuration object
Activates a license with the license server and updates local license data. When activating user based license we advise that unique_license_id is set which represent "id" field within the license check.
Key-based
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H6QM-6H5R-ZENJ-VBLK")
license = manager.activate_license(license_id)
User-based
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)
Parameters:
Return: License object representing the activated license.
Loads the license file and sets attributes for the LicenseData instance. Returns an instance of the License class reflecting the loaded license.
manager = LicenseManager(conf)
license = manager.load_license()
Return: License object representing the activated license.
Get current configuration
manager = LicenseManager(conf)
config = manager.current_config()
Return (dict): current configuration
Change the current configuration
Parameters:
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,
)
)
Checks if licensefile is corrupted
manager = LicenseManager(conf)
boolean = manager.is_license_file_corrupted()
Return (bool): If the file is corrupted return True, otherwise False
Clear all data from current product
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H6QM-6H5R-ZENJ-VBLK")
license = manager.activate_license(license_id)
manager.clear_local_storage()
Get licensefile location
manager = LicenseManager(conf)
folder_path = manager.data_location()
Return (str): Licensefile location
Set data location
Parameters:
manager = LicenseManager(conf)
manager.set_data_location()
Return: None
Get licensefile name
manager = LicenseManager(conf)
file_name = manager.license_file_name()
Return (str): Licensefile name
Set licensefile name
Parameters:
manager = LicenseManager(conf)
manager.set_license_file_name()
Return: None
Checks if the licensing server is accessible. Returns True if online, False otherwise.
Parameters:
manager = LicenseManager(conf)
license = manager.is_online()
Get activation code for air gap license
Parameters:
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
Parameters:
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:
Return (License): License
Creates .req file for offline activation, including various optional parameters related to the device and software environment.
Parameters:
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')
Return (str): Path of the .req file created for activation.
Activates a license offline using a .lic file provided via the specified path.
Parameters:
file_path = 'offline_files/ls_activation.lic'
manager = LicenseManager(conf)
license = manager.activate_license_offline(file_path)
Raises:
Return(License): Returns a License object representing the activated license.
Creates LiceseID for trial licenses
Parameters:
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 versions
Parameters:
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
Parameters:
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
Parameters:
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
Parameters:
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
Object responsible for license operations
Determines wheter the license floating period has expired
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
license.check()
response = license.is_floating_expired()
Return (bool): True if license floating period has expired otherwise False
Retrieve license flaoting timeout
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
print(license.floating_timeout())
Return (int): License floating timeout
Check if license is floating (Floating Server or Floating Cloud)
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
print(license.is_floating())
Return (bool): True if license if floating, otherwise False
Get floating client id
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
print(license.floating_client_id())
Return (str): Floating client id
Check if license is controlled by Floating Server
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
print(license.is_controlled_by_floating_server())
Return (bool): True if license is controlled by floating server, otherwise False
Number of floating devices in use
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
print(license.floating_in_use_devices())
Return (int): Number of floating devices in use
Datetime when flaoting will be released
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
print(license.floating_end_date())
Return (datetime): Datetime when device will be released
Number of max floating users
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
print(license.max_floating_users())
Return (int): Number of max floating users
Determines whether the license's validity period has expired
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.is_validity_period_expired()
Return (bool): True if license expired;False if license is valid
Gets validity period of the license
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.validity_period()
Return (datetime): Datetime in UTC
Gets the validity period with grace period of the license
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.validity_with_grace_period()
Return (datetime): Datetime in UTC
Gets the license user
user_data = license.license_user()
print(user_data)
Return (dict): license user
Gets how many days are left until the maintenance ends
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.maintenance_days_remaining()
Return (int): Maintenance days left
Gets how many days are left until the validity period ends
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.days_remaining()
Return (int): Validity period days left
Gets customer information
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.customer_information()
Return (dict): customer information
Gets license id
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.id()
Return (int): license id
Get the max transfers
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.max_transfers()
Return (int): max transfers
Get the transfer count
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.transfer_count()
Return (int): transfer count
Get if the device transfer is allowed
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.is_device_transfer_allowed()
Return (bool): True if device transfer is allowed otherwise False.
Get if the device transfer is limited
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.is_device_transfer_limited()
Return (bool): True if device transfer is limited otherwise False.
Get how many days passed since last check
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
license.check()
response = license.days_since_last_check()
Return (int): How many days have passed since last check.
Get the start date of the license
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.start_date()
Return (datetime): Datetime in UTC
Get the maintenance period of the license
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.maintenance_period()
Return (datetime): Datetime in UTC
Checks if maintence period has expired
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.is_maintence_period_expired()
Return (bool): If maintence period expired returns True otherwise False
Gets when the last check was performed
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.last_check()
Return (datetime): Datetime in UTC
Gets when the last license usage
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.last_usage()
Return (datetime): Datetime in UTC
Gets the license type
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.license_type()
Return (str): License type
Gets the license max activations
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.max_activations()
Return (int): max activations
Gets the license metadata
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.metadata()
Return (dict): metadata
Check if unlimited activationsis allowed
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.allow_unlimited_activations()
Return (bool): If unlimited activations is allowed returns True otherwise False
Check if grace subscription period is allowed
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.allow_grace_subscription_period()
Return (bool): If grace subscription period is allowed returns True otherwise False
Check if grace subscription period has started
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.is_subscription_grace_period_started()
Return (bool): If grace subscription period has started returns True otherwise False
Check if license is in grace period
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.is_grace_period_started()
Return (bool): True if grace period has started, otherwise False
Get remain hours of grace period
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.grace_period_hours_remaining()
Return (int): Number of hours left in grace period
Get grace period
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.get_grace_period()
Return (int): grace period
Get subscription grace period
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.subscription_grace_period()
Return (int): subscription grace period
Checks if the license validity has expired
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.is_expired()
Return (bool): True if license has expired otherwise False
Checks if the license is enabled
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.license_enabled()
Return (bool): True if license is enabled otherwise False
Checks if the license is active
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.license_active()
Return (bool): True if license is active otherwise False
Checks if the license is valid (license is active, enabled and didn't expired)
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.is_valid()
Return (bool): True if license is valid otherwise False
Checks if the license prevents virtual machines
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.prevent_vm()
Return (bool): True if license prevents VM's otherwise False
Checks if the license is trial
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.is_trial()
Return (bool): True if license is trial otherwise False
Get expiry date of floating license
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.expiry_date()
Return (datetime): Expiry date in UTC
Get the date until a license is borrwed
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.borrow_until()
Return (datetime): borrow_until in UTC
Check if a license is borrowed
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.is_borrowed()
Return (bool): True if license is borrowed otherwise False
Get local consumptions
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.local_consumptions()
Return (int): local consumptions
Get max consumptions
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.max_consumptions()
Return (int): max consumptions
Get total consumptions
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.total_consumptions()
Return (int): total consumptions
Get max overages
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.max_overages()
Return (int): max_overages
Check if unlimited consumptions is allowed
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.allow_unlimited_consumptions()
Return (int): If unlimited consumptions are allowed return True otherwise False
Check if there is consumption reset
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.consumption_reset()
Return (bool): If there is consumption reset returns True otherwise False
Check if overages are allowed
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.allow_overages()
Return (bool): If overages are allowed returns True otherwise False
Get consumption period
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
response = license.allow_overages()
Return (str): Consumption period
Get feature data
Parameters:
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
feature_code = "feature1"
response = license.get_feature_data(feature_code)
Return (dict): Feature
Get feature list
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
print(license.features())
Return (list): Features
Verifies the current status of the license. It raises exceptions if the license is not enabled, not active, or expired
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:
Return: None
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.
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.
Deactivates the license and optionally deletes the local license file.
Parameters:
delete_license (bool, optional): If True, deletes the local license file upon deactivation.
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
license.deactivate()
Return: None
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.
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
Adds local consumption records for consumption-based licenses. Parameters:
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
Synchronizes local consumption data with the server, adjusting for overages if specified.
Parameters:
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.
Determines if the current license state is within its grace period following a specific exception.
Parameters:
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
Changes password of a user
Parameters:
password (str): Old password of license user
new_password(str): New password of license user
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(password="7t_x3!o9",new_password="12345678")
Return (str): "password_changed"
Initializes and starts the license watchdog with the specified callback and timeout settings.
Parameters:
callback (Callable): A callable to be executed by the watchdog in response to specific events or conditions.
timeout (int): The period in minutes after which the watchdog should perform its checks.
deamon (bool, optional): Run thread as deamon. Defaults to False.
run_immediately (bool,optional): run license check immediately, if False wait for timeout first.
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
license.setup_license_watch_dog(callback,timeout)
Return: None
Stops the license watchdog if it is currently running, effectively halting its monitoring and callback activities.
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
license.setup_license_watch_dog(callback,timeout)
license.stop_license_watch_dog()
Return: None
Initializes and starts the feature watchdog with the specified callback and timeout.
Parameters:
callback (Callable): A callable to be executed by the watchdog in response to specific events or conditions.
timeout (int): The period in minutes after which the watchdog should perform its checks.
deamon (bool, optional): Run thread as deamon. Defaults to False.
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
license.setup_feature_watch_dog(callback,timeout)
Return: None
Stops the feature watchdog if it is currently running.
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
license.setup_feature_watch_dog(callback,timeout)
license.stop_feature_watch_dog()
Return: None
Adds local consumption to the feature.
Parameters:
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
Synchronizes local consumption data with the server. Parameters:
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")
Return (bool): True if the consumption data was successfully synchronized; False otherwise.
Attempts to borrow a floating license until the specified date, updating the system status based on the outcome of the borrow attempt.
Parameters:
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
Releases a borrowed floating license and updates the license status accordingly.
Parameters:
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
license.check()
license.floating_release(False)
Return: None
Checks for a specific license feature and updates the license cache accordingly.
Parameters:
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
license.check_feature("lkprod1f1fc1")
Return: None
Releases a borrowed license feature and updates the license cache accordingly.
Parameters:
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")
Return: None
Updates license via refresh file
Parameters:
file_path = 'path_to_lic_file/license.lic'
manager = LicenseManager(conf)
license = manager.activate_license_offline(file_path)
license.update_offline('offline_files/license_refresh.lic',False)
Raises:
Return(bool): True if license was successfully updated otherwise False
Get deactivation code for air gap licenses
Parameters:
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 license and clear storage
Parameters:
confirmation_code="your_confirmation_code"
manager = LicenseManager(conf)
#load air gap license
license = manager.load_license()
license.deactivate_air_gap(confirmation_code)
Raises:
Return: None
Generates .req file for the offline deactivation
Parameters:
file_path = 'path_to_lic_file/license.lic'
manager = LicenseManager(conf)
license = manager.activate_license_offline(file_path)
license.deactivate_offline('path_where_to_create_req_file')
Raises:
Return(bool): True if license was successfully updated otherwise False
Update product details from LicenseSpring server
Parameters:
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H9V3-72XX-ZRAJ-S6LK")
license = manager.activate_license(license_id)
response = license.product_details()
Raises:
Return(dict): response
Get product details from licensefile (offline)
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H7G3-F4PJ-4AEJ-UKYL")
license = manager.activate_license(license_id)
feature_code = "feature1"
response = license.get_product_details()
Return (dict): Product details
Get device variable if exists
Parameters:
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H9V3-72XX-ZRAJ-S6LK")
license = manager.activate_license(license_id)
device_var = license.get_device_variable('english')
Raises:
Return(dict): variable dictionary
Set device variables locally
Parameters:
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H9V3-72XX-ZRAJ-S6LK")
license = manager.activate_license(license_id)
license.set_device_variables({"english":"value"})
Raises:
Return: None
Get device variables from server or locally
Parameters:
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H9V3-72XX-ZRAJ-S6LK")
license = manager.activate_license(license_id)
license.get_device_variables(get_from_be=True)
Raises:
Return(list): List of device variables
Send device variables to LicenseSpring server. Handles GracePeriod
manager = LicenseManager(conf)
license_id = LicenseID.from_key("H9V3-72XX-ZRAJ-S6LK")
license = manager.activate_license(license_id)
license.send_device_variables()
Raises:
Return(bool): True if new variables are sent to LicenseSpring server otherwise, False
Get custom fields from licensefile
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
The user has the ability to utilize either a Floating Client or a Floating Manager:
Floating Client:
Floating Manager:
To initialize a Floating Client, the user must specify the API protocol and domain.
from licensespring.floating_server import FloatingAPIClient
from licensespring.hardware import HardwareIdProvider
api_client = FloatingAPIClient(api_protocol="http", api_domain="localhost:8080",hardware_id_provider=HardwareIdProvider)
Authenticate
Parameters:
from licensespring.floating_server import FloatingAPIClient
api_client = FloatingAPIClient(api_protocol="http", api_domain="localhost:8080")
api_client.auth(username="admin",password="tetejac")
Return(dict): Response
Register user
Parameters:
api_client = FloatingAPIClient(api_protocol="http", api_domain="localhost:8080")
response = api_client.register_user(
product="lkprod1",
user="user_1",
os_hostname="bla",
ip_local="bla",
user_info="bla",
license_id=1728377159207169
)
print(response)
Return(dict): Response
Parameters
Unregister user
api_client = FloatingAPIClient(api_protocol="http", api_domain="localhost:8080")
response = api_client.unregister_user(product="lkprod1",user="user_1",license_id=1728377159207169)
print(response)
Return(str): "user_unregistered"
Unregister all users
api_client = FloatingAPIClient(api_protocol="http", api_domain="localhost:8080")
api_client.unregister_all()
Borrow license
Parameters
api_client = FloatingAPIClient(api_protocol="http", api_domain="localhost:8080")
response = api_client.borrow(
product="lkprod1",
user="user_1",
borrowed_until="2029-05-06T00:00:00Z",
os_hostname="bla",
ip_local="bla",
user_info="bla",
license_id=1728377159207169,
)
Return(dict): Response
Add license consumption
Parameters
api_client = FloatingAPIClient(api_protocol="http", api_domain="localhost:8080")
response = api_client.add_consumption(product="fs", consumptions=1)
Return(dict): Response
Add feature consumption
Parameters
api_client = FloatingAPIClient(api_protocol="http", api_domain="localhost:8080")
response = api_client.add_feature_consumption(product="fs", feature_code="f2", consumptions=1)
Return(dict): Response
Register feature
Parameters
api_client = FloatingAPIClient(api_protocol="http", api_domain="localhost:8080")
response = api_client.feature_register(
product="fs", feature_code="f1", os_hostname="w", ip_local="1.0", user_info="info"
)
print(response)
Return(dict): Response
Feature release
Parameters
api_client = FloatingAPIClient(api_protocol="http", api_domain="localhost:8080")
response = api_client.feature_register(
product="fs", feature_code="f1", os_hostname="w", ip_local="1.0", user_info="info"
)
response = api_client.feature_release(product="fs", feature_code="f1")
Return(str): "feature_released"
To intialize Floating Manager Configuration needs to be created. For Floating server you can set arbitrary values for shared_key and api_key keys.
Authenticate
Parameters:
from licensespring.licensefile.config import Configuration
from licensespring.licensefile.floating_manager import FloatingManager
fs_manager = FloatingManager(conf=conf)
fs_manager.auth(username="admin",password="tetejac")
Return(dict): Response
Register license
Parameters:
from licensespring.licensefile.config import Configuration
from licensespring.licensefile.floating_manager import FloatingManager
conf = Configuration(
product=product,
api_key="arbitrary",
shared_key="arbitrary",
file_key="your_file_key",
file_iv="your_file_iv",
api_domain="api_domain",
api_protocol="http/https",
)
fs_manager = FloatingManager(conf=conf)
license = fs_manager.register()
Return(License): License object
Parameters
Unregister license
fs_manager = FloatingManager(conf=conf)
# There are multiple options to unregister a license
# 1. floating client -> this one is documanted
fs_manager.unregister()
# 2.1. license object -> deactivate method
license.deactivate()
#2.2 license object -> floating release
license.floating_release(False)
Return(str): "user_unregistered"
Unregister all users
fs_manager = FloatingManager(conf=conf)
fs_manager.unregister_all()
Borrow license
Parameters
fs_manager = FloatingManager(conf=conf)
license = fs_manager.borrow("2031-05-06T00:00:00Z")
# borrow can be also used within the License object
license.floating_borrow("2031-05-06T00:00:00Z")
Return(License): License object
Checks if floating server is online
Parameters
fs_manager = FloatingManager(conf=conf)
response = fs_manager.is_online()
Raises:
Return(bool): True if server is online, otherwise False
License consumptions, feature consumptions, register feature, release feature are supported within License object for Floating Server
Copyright (C) 2023 by Cense Data Inc., support@licensespring.com
| Name | Version | License | URL |
|---|---|---|---|
| certifi | 2023.7.22 | Mozilla Public License 2.0 (MPL 2.0) | https://github.com/certifi/python-certifi |
| charset-normalizer | 3.3.0 | MIT License | https://github.com/Ousret/charset_normalizer |
| idna | 3.4 | BSD License | https://github.com/kjd/idna |
| pycryptodome | 3.19.0 | Apache Software License; BSD License; Public Domain | https://www.pycryptodome.org |
| requests | 2.31.0 | Apache Software License | https://requests.readthedocs.io |
| urllib3 | 2.0.7 | MIT License | https://github.com/urllib3/urllib3/blob/main/CHANGES.rst |
| winregistry | 1.1.1 | UNKNOWN | https://github.com/shpaker/winregistry |
FAQs
LicenseSpring Python Library
We found that licensespring demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 2 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
PyPI confirms no security flaws were exploited in the Ultralytics supply chain attack and highlights improvements for safer package publishing.
Security News
Research
The Socket Research Team breaks down a malicious wrapper package that uses obfuscation to harvest credentials and exfiltrate sensitive data.
Research
Security News
Attackers used a malicious npm package typosquatting a popular ESLint plugin to steal sensitive data, execute commands, and exploit developer systems.