arcgis.gis.video module | ArcGIS API for Python

VideoServer

class arcgis.gis.video.VideoServer(url: str, gis=None)

Bases: BaseVideoServer

Object representing the main entry point for an ArcGIS Video Server site.

Access management capabilities for resources such as machines, services, logs, security, system, data, and uploads and the operations available through these resources using the admin property to initialize administrative access, and then using subsequent properties and methods on that object.

Objects of this class are not initialized directly, but instead are obtained using the get() or the list() methods of the API’s ServerManager to retrieve a VideoServer instance.

Example: Get a VideoServer object using ServerManager.list()

from arcgis.gis import GIS

gis = GIS(profile="your_enterprise_admin_profile")
server_mgr = gis.admin.servers
servers = server_mgr.list()

video_server_index = next(
    index
    for index, server in enumerate(servers)
    if isinstance(server, VideoServer)
)
video_server = servers[video_server_index]
print(f"Video server object: {video_server}")
print(f"Type of object: {type(video_server)}")

Output:

Video server object: < VideoServer @ https://example.com:21443/arcgis/admin >
Type of object: <class 'arcgis.gis.video.api.VideoServer'>

Example #2: Get a VideoServer object using ServerManager.get()

from arcgis.gis import GIS

gis = GIS(profile="your_enterprise_admin_profile")
server_mgr = gis.admin.servers

vid_server = server_mgr.get(function="VideoServer")[0]

print(f"Video server object: {vid_server}")
print(f"Type of object: {type(vid_server)}")

Output:

Video server object: < VideoServer @ https://example.com:21443/arcgis/admin >
Type of object: <class 'arcgis.gis.video.api.VideoServer'>

property admin: AdminVideoServer

Return the root administrative endpoint for the ArcGIS Video Server’s collection of resources. You can access functional areas - ranging from machines to services, logs, and uploads amongst others - through various properties available on this object.

Returns:: An AdminVideoServer instance.

Example: Access the administrative endpoint for a site:

from arcgis.gis import GIS

gis = GIS(profile="your_enterprise_admin_profile")
server_mgr = gis.admin.servers
vid_server = server_mgr.get(function="VideoServer")[0]

vid_admin = vid_server.admin
print(f"Video server admin object: {vid_admin}")
print(f"Type of object: {type(vid_admin)}")

Output:

Video server admin object: < AdminVideoServer @ https://example.com:21443/arcgis/admin >
Type of object: <class 'arcgis.gis.video.admin.api.AdminVideoServer'>

property info: dict[str, Any]

Returns a python dict containing site-level metadata, including current version and authentication type, for the site.

Returns:: A python dict containing server information returned from the info REST API resource.

Example: Get metadata about the Video Server site:

from arcgis.gis inport GIS
gis = GIS(profile="your_enterprise_admin_profile")

vid_server = gis.admin.servers.get(function="VideoServer")[0]
vs_info = vid_server.info
print(vs_info)

Output:

{'owningSystemUrl': 'https://example.com/<web_adaptor>',
 'fullVersion': '12.2.0',
 'currentVersion': 12.2,
 'authInfo': {'tokenServicesUrl': 'https://example.com/<web_adaptor>/sharing/rest/generateToken',
 'isTokenBasedSecurity': True}}

Administrative Classes

AdminVideoServer

class arcgis.gis.video.admin.api.AdminVideoServer(url: str, session: EsriSession)

Bases: object

Class providing access to the administrative root resource for an ArcGIS Video Server site.

Exposes manager objects for the collection of resources that provide access to additional resources and operations for administering a Video Server site.

Objects of this class are not initialized directly. Use the admin property of a VideoServer object to obtain an instance:

Example: Initialize an AdminVideoServer object for a Video Server site:

from arcgis.gis import GIS
gis = GIS(profile="your_enterprise_admin_profile")

server_mgr = gis.admin.servers
vid_server = server_mgr.get(function="VideoServer")[0]

vid_admin = vid_server.admin
print(f"Video server admin object: {vid_admin}")
print(f"Type of object: {type(vid_admin)}")

Output:

Video server admin object: < AdminVideoServer @ https://example.com:21443/arcgis/admin >
Type of object: <class 'arcgis.gis.video.admin.api.AdminVideoServer'>

property about: dict[str, Any]

Return hardware, extension, and license metadata from the Video Server About resource. Detailed explanation and example of output information provided at the link.

Returns:: A python dict with current information. The key-value pairs will vary depending on the server configuration.

Example: Get server about metadata

from arcgis.gis import GIS

gis = GIS(profile="your_enterprise_admin_profile")
vid_server = gis.admin.servers.get(function="VideoServer")[0]

about_info = vid_server.admin.about
about_info

Output:

{'currentBuild': '1547',
 'serverRole': 'FEDERATED_SERVER',
 'lastUpdated': 1785280314492,
 ...
 'serverType': 'ARCGIS_VIDEO_SERVER',
 'machines': [...],
  ...
 'serverFunction': 'VideoServer',
 'webAdaptors': [...]
}

property backup_restore_info: dict[str, Any]

Reports information regarding the current backup settings for Video Server. This will include timestamps and flags for full and incremental backup and restore activity.

Example: Get backup and restore information for the current site:

from arcgis.gis import GIS
gis = GIS(profile="your_enterprise_admin_profile")

vid_server = gis.admin.servers.get(function="VideoServer")[0]
backup_info = vid_server.admin.backup_restore_info
backup_info

Output: Example return values

{
    'incrementalBackupTimeStamp': 0,
    'incrementalRestoreTimeStamp': 0,
    'incrementalBackupEnabled': False,
    'fullBackupTimeStamp': 0,
    'fullRestoreTimeStamp': 0,
    'backupModeTimeStamp': 0
}

property data: DataManager

Return a resource with information and management capabilities for the data items of the server. Provides the capability to find, register, and validate datastores.

Returns:: A DataManager object.

delete_site() → dict[str, Any]: Delete the current site configuration and release server resources.

Note

This is an unrecoverable operation. Use caution because it removes services, settings, and site configuration.

delete_upload(id: str) → dict[str, Any]

Delete a previously uploaded item by its identifier.

Parameter	Description
id	Required string. The `file_id` value for the uploaded item to delete.

Returns:: A python dict containing a status key or an error message if the delete failed.

Example: Delete an uploaded item by its ID

from arcgis.gis import GIS
gis = GIS(profile="your_enterprise_admin_profile")
vid_server = gis.admin.servers.get(function="VideoServer")[0]
vid_admin = vid_server.admin

upload_list = vid_admin.uploads()
# Get the upload at the first index position of the list
upload_id = upload_list[0].file_id

response = vid_admin.delete_upload(id=upload_id)

export_site(destination: str, validate: bool) → dict[str, Any]

Export the current site configuration to a destination path. See the Export Site reference documentation for full description of the operation.

Parameter	Description
destination	Required string. The file path or a reference ID from the server to the stored configuration information.
validate	Required boolean. Indicates whether the operation will validate the site archive before exporting.

import_site(location: str, validate: bool) → dict[str, Any]

Import a site configuration into the current site. Replaces existing services and administrative configuration with the imported site archive content. See the Import Site reference documentation for full description of the operation.

Parameter	Description
location	Required string. The file path to the site archive to import.
validate	Required boolean. Indicates whether the operation will validate the site archive before importing.

property info: dict[str, Any]

Return site-level metadata about the current Video Server site.

The response contains deployment metadata and login information for the current site and session.

Returns:: A python dict of metadata information:

Example: Administrative metadata for the current session:

from arcgis.gis import GIS
gis = GIS(profile="your_enterprise_admin_profile")

vid_server = gis.admin.servers.get(function="VideoServer")[0]
vid_admin_info = vid_server.admin.info
print("Video server admin info:")
vid_admin_info

Output:

{'fullVersion': '12.2.0',
 'configStoreVersion': '3',
 'loggedInUserPrivilege': 'ADMINISTER',
 'currentversion': '12.2.0',
 'loggedInUser': 'VidServer_admin',
 'currentbuild': '1000'}

property logs: LogsManager

Return the logs manager for querying, cleaning, and configuring logs.

Returns:: LogsManager

property machines: MachineManager

Provides access to a MachineManager helper class to manage the machine resources, with ability to perform machine-level inspection and administration operations.

Example: Access the machine manager

from arcgis.gis import GIS

gis = GIS(profile="your_enterprise_admin_profile")
vid_server = gis.admin.servers.get(function="VideoServer")[0]

machine_mgr = vid_server.admin.machines
print(type(machine_mgr))

Output:

<class 'arcgis.gis.video.admin.machines.api.MachineManager'>

property mode: dict[str, Any]

Get or set the current site mode of the Video Server site. See the Video Server Mode documentation for detailed explanantion of the resource this property accesses.

Returns:: A python dict with current site mode information, typically including siteMode, copyConfigLocal, and lastModified keys.

To set the site mode, assign the mode property to a new SiteMode object of either READ_ONLY or EDITABLE. Use:

READ_ONLY to block most administrative operations and service publishing.
EDITABLE to allow normal operations. An error is returned if the update fails.

Example: Set the site mode to READ_ONLY:

from arcgis.gis import GIS
from arcgis.gis.video.admin import SiteMode

gis = GIS(profile="your_enterprise_admin_profile")

vid_server = gis.admin.servers.get(function="VideoServer")[0]
vid_admin = vid_server.admin

vid_admin.mode = SiteMode.READ_ONLY

property queue_info: dict[str, Any]

Provides details about the system store that handles the messaging and stability for the Video Server site.

Primary functions include updating service changes so webhooks can query them, and coordinating multiple video uploads to ensure system reliability.

Returns:: A python dict of information with queueLength, numListeners, and name keys.

Example: Get queue information for the current site

from arcgis.gis import GIS

gis = GIS(profile="your_enterprise_admin_profile")
vid_server = gis.admin.servers.get(function="VideoServer")[0]

queue_info = vid_server.admin.queue_info
queue_info

Output:

{'queueLength': 0, 'numListeners': 3, 'name': 'default'}

property security: SecurityManager

Return the security manager to manage all security operations avialable for a Video Server site.

Returns:: SecurityManager

property services: ServiceManager

Return the services manager for administrative service operations.

Returns:: ServiceManager

property session: EsriSession

Return the current session object.

Example: Access the active session object

from arcgis.gis import GIS

gis = GIS(profile="your_enterprise_admin_profile")
vid_server = gis.admin.servers.get(function="VideoServer")[0]
vid_admin = vid_server.admin

current_session = vid_admin.session
print(type(current_session))

Output:

<class 'arcgis.auth._auth._token.EsriSession'>

property system: SystemManager

Return the system manager for server-wide configuration resources.

Returns:: SystemManager

Example: Access the system manager

from arcgis.gis import GIS

gis = GIS(profile="your_enterprise_admin_profile")
vid_server = gis.admin.servers.get(function="VideoServer")[0]

system_mgr = vid_server.admin.system
print(type(system_mgr))

Output:

<class 'arcgis.gis.video.admin.system.api.SystemManager'>

uploads() → Iterable[Upload]

Get the uploaded items currently stored on the server.

Returns:: A Python list of Upload objects representing the uploaded items currently stored on the server.

Example: Get the list of uploaded items

from arcgis.gis import GIS
gis = GIS(profile="your_enterprise_admin_profile")
vid_server = gis.admin.servers.get(function="VideoServer")[0]
vid_admin = vid_server.admin

uploaded_items = vid_admin.uploads()

print(f"Object Type: {type(uploaded_items[0])}")
for upload in uploaded_items:
    print(f"Upload ID: {upload.file_id}, File Name: {upload.file_name}")

Output: Example of printing some properties of the uploaded items

Object Type: <class 'arcgis.gis.video.admin.model.Upload'>
Upload ID: i01214f77-e32a-4e38-bafe-9a330a4ab7f6, File Name: Factory_1.mpg

property url: str

Returns the root administrative resource URL endpoint.

Example: Read the admin root URL

from arcgis.gis import GIS

gis = GIS(profile="your_enterprise_admin_profile")
vid_server = gis.admin.servers.get(function="VideoServer")[0]
vid_admin = vid_server.admin

print(vid_admin.url)

Output:

https://example.com:21443/arcgis/admin

Administrative Logs Management

LogsManager

class arcgis.gis.video.admin.logs.api.LogsManager(url: str, session: EsriSession)

Bases: object

Manager object for the server records written by the various components of the Video Server instance. Supports setting retrieval/updates, log querying, log cleanup, and error report access.

Returned by the logs property.

clean() → bool

Delete all log records across site machines. The server will periodically clean up old log records without running this operation, but this operation can be used to immediately remove all log records.

Returns:: A boolean indicating success (True) or failure (False).

error_reports() → dict[str, Any]

Return the list of available error report files.

Returns:: A dictionary with the error report listing

get_error_report(filename: str) → str

Return the text contents of a specific error report file.

Argument	Description
filename	Required string. The name of the error report file to retrieve. This should be one of the files returned by the `error_reports()` method.

Returns:: A dictionary with the error report listing

property properties: dict[str, Any]: Return metadata information about the logs endpoint of the Video Server, including available operations and resources.

query(query: LogQuery) → Iterable[LogQueryResult]

Operation to query and retrieve all the log messages across the entire ArcGIS Video Server site.

Argument	Description
query	Required `LogQuery` object containing criteria to refine the output.

Returns:: An iterable of LogQueryResult objects.

property session: EsriSession: Return the current session object.

property settings: LogSettings

Retrieve and/or set information about the current log settings.

Returns:: A LogSettings object.

property url: str: The current URL

LogSettings

pydantic model arcgis.gis.video.admin.logs.model.LogSettings

Class to manage the current log settings for the Video Server deployment.

field directory: str | None [Required]: The location on the server where the logs reside

field error_report_count: int [Required]: The number of error reports to keep on the server.

field level: LogLevel | None [Required]: The logging level for the server

field log_age: int [Required]

The length the logs will keep on the server.

Constraints:

gt = 0
le = 90

LogQuery

pydantic model arcgis.gis.video.admin.logs.model.LogQuery

A class representing the query parameters used as the query argument when using the query() method to query the logs.

field end_time: _dt.datetime | None = None: The oldest time to include in the result set. You can use this to limit the query to the last few minutes or hours as needed.

field filter: Filter = Filter(codes=[], process_ids=[], request_ids=None, component=<Component.ALL: '*'>, services='*', machines='*'): Filtering provides flexibility and specificity by combining any of the filter properties from the Filter dataclass.

field level: LogLevel | None [Required]: The logging level for the server

field page_size: int = 1000

The maximum number of log records to be returned by this query. The default messages per page is 1000. The limit is 10000 records.

Constraints:

gt = 0
le = 1000

field start_time: _dt.datetime | None = None: The most recent time to query. If the hasMore member of the response object is true, pass the endTime member as the startTime parameter for the next request to get the next set of records. Time can be specified in milliseconds since UNIX epoch or as an ArcGIS Server time stamp.

serialize_as_json_string(f: Filter, _info) → str

serialize_time_epoch(dt: datetime, _info) → int | str

Filter

pydantic model arcgis.gis.video.admin.logs.model.Filter

Filter criteria for narrowing log query results for use as the filter value in a LogQuery object.

field codes: list[int] | None = []: Specifies the log codes assigned to server logs. To query all codes, set the value to [].

field component: Component | None = Component.ALL: Specifies the server components delivering the log message. To query logs from all components, set the value to ALL.

field machines: str | list[str] | None = '*': Specifies whether to query all or a specific machine in your server site. To query logs from all machines, set the value to *.

field process_ids: list[int] | None = []: Specifies the machine process IDs to query. The default is all process ids.

field request_ids: list[str] | None = None: Specifies an ID assigned to a specific server request.

field services: str | list[str] | None = '*': Specifies whether to query all, none, or a specific service in your site. To query logs from all services, set the value to *.

serialize_list_with_brackets(items: List[str], _info)

LogQueryResult

pydantic model arcgis.gis.video.admin.logs.model.LogQueryResult

Object returned by the query method of the LogsManager.

field end_time: _dt.datetime | int | None = None: The most recent time to query.

field has_more: bool [Required]: Indicates whether additional result pages are available.

field messages: list[dict] | None = None: The list of messages from the query result.

field start_time: _dt.datetime | int | None = None: The most recent time to query.

LogLevel

class arcgis.gis.video.admin.logs.model.LogLevel(*values)

Supported server log severity levels.

DEBUG = 'DEBUG'

FINE = 'FINE'

INFO = 'INFO'

OFF = 'OFF'

SEVERE = 'SEVERE'

VERBOSE = 'VERBOSE'

WARNING = 'WARNING'

Administrative Security Management

SecurityManager

class arcgis.gis.video.admin.security.api.SecurityManager(url: str, session: EsriSession)

Bases: object

Manage the video server site security resources. Exposes security configuration, server-role transitions, and primary site administrator (PSA) operations.

Objects of this class are not meant to be instantiated directly, but instead are accessed through the security property of the AdminVideoServer object.

Example: Initialize a SecurityManager object

from arcgis.gis import GIS

gis=GIS(profile="your_enterprise_admin_profile")

vid_server = gis.admin.servers.get(role="VideoServer")[0]
vid_admin = vid_server.admin

security_mgr = vid_admin.security
security_mgr

Output:

< SecurityManager @ https://example.site.com/videoserver/admin/security >

change_server_role(role: ServerRole, function: str | None = None) → None

Change server role or function. Video Server deployments may perform queue-store synchronization during role changes depending on server function.

Parameter	Description
role	A required `ServerRole` member representing the new server role.
function	The new server function to assign (optional). Only valid values is VideoServer.

property config: SecurityConfiguration: Gets a SecurityConfiguration object containing information about the security resource endpoint.

property properties: dict[str, Any]: Return security root metadata and available child resources.

property psa_properties: dict[str, Any]: Return PSA account metadata.

property session: EsriSession: Return the current session object.

set_psa_access(enabled: bool) → dict[str, str]

Enable or disable PSA account login access.

Parameter	Description
enabled	A Python `boolean` indicating whether to enable or disable PSA access.

update_psa(username: str | None = None, password: str | None = None) → dict[str, str]: Update PSA credentials.

property url: str: Get the current URL endpoint for the security resource.

PortalProperties

pydantic model arcgis.gis.video.admin.security.model.PortalProperties

Federation metadata linking Video Server to Portal for ArcGIS.

field portal_mode: str [Required]: The portal mode. This must be ‘ARCGIS_PORTAL_FEDERATION’.

field portal_url: str [Required]: The URL of Portal for ArcGIS.

field private_hosting_server_url: str [Required]: The private URL of the portal’s hosting server.

field private_portal_url: str [Required]: The internal URL of Portal for ArcGIS.

field server_id: str [Required]: The ID of the server federated with the portal.

field server_url: str [Required]: The external URL of the server federated with the portal.

SecurityConfiguraton

pydantic model arcgis.gis.video.admin.security.model.SecurityConfiguration

Helper class for getting, setting, and managing the security operations on a video server deployment. Objects of this class are returned by the config property of a SecurityManager object, and can be updated and used to set new configuration values.

field allow_direct_access: bool [Required]: A Boolean that indicates whether a user with administrator privileges can access the server through port 2180. If true, all users with administrative access can access the Administrator Directory and ArcGIS Video Server Manager through port 2180. If false, users in the identity store cannot access the server through port 2180; users must access the site through ArcGIS Web Adaptor. The default value is true.

field allow_internet_cors_access: bool [Required]: A Boolean that controls the value of the Access-Control-Allow-Private-Network response header in a CORS preflight request to a REST service URL. This property supports the Private Network Access web specification (previously CORS-RFC1918), which aims to restrict websites accessed over a private network from making internal cross-origin requests.

field authentication_mode: str [Required]: Current authentication mode active for the deployment.

field authentication_tier: AuthenticationTier [Required]: Specifies the tier at which requests to access video services will be authenticated.

field cipher_suites: str [Required]: The cipher suites ArcGIS Video Server will use. The Valid cipher suites section below outlines the ciphers enabled by default, as well as valid ciphers that can be enabled.

field https_protocols: str [Required]: The TLS protocols ArcGIS Video Server will use. TLSv1.2 and TLSv1.3 (support for TLSv1.3 was added at 10.9) is enabled by default. You can also enable TLSv1 and TLSv1.1. Values must be separated by commas.

field portal_properties: PortalProperties [Required]: The properties used when federating ArcGIS Video Server with Portal for ArcGIS.

field server_function: str [Required]: The designated function of the server. This should be ‘VideoServer’ for a Video Server site.

field server_role: ServerRole [Required]: The name of the server role.

field server_type: str [Required]: The type of server. For a Video Server, this should be ‘ARCGIS_VIDEO_SERVER’.

field token_service_key: str [Required]: Internal signing/encryption key material used by the server token service.

AuthenticationTier

class arcgis.gis.video.admin.security.model.AuthenticationTier(*values)

Authentication tier options accepted by security configuration updates.

ARCGIS_PORTAL = 'ARCGIS_PORTAL'

GIS_SERVER = 'GIS_SERVER'

WEB_ADAPTOR = 'WEB_ADAPTOR'

ServerRole

class arcgis.gis.video.admin.security.model.ServerRole(*values)

Supported administrative server role values.

FEDERATED_SERVER = 'FEDERATED_SERVER'

STANDALONE_SERVER = 'STANDALONE_SERVER'

Administrative Services Management

ServiceManager

class arcgis.gis.video.admin.services.api.ServiceManager(url: str, session: EsriSession)

Bases: object

Manager object for administrative operations on Video Server services. This manager provides operations for listing services, checking existence, creating empty containers, and retrieving service resources.

Objects of this type are returned by the services property of a AdminVideoServer instance.

Example: Get a ServiceManager for a Video Server instance

from arcgis.gis import GIS
from arcgis.gis.video import VideoServer

gis = GIS(profile="your_enterprise_admin_profile")
vid_server = gis.admin.servers.get(function="VideoServer")[0]
svc_mgr = vid_server.admin.services
svc_mgr

Output:

< ServiceManager @ https://exampleserver.domain.com/webadaptor/video/admin/services >

create(service_name: str) → CreateResponse

Create a new video service container for layers.

Returns:: CreateResponse

exists(service_name: str) → bool

Check whether a named service exists.

Parameter	Description
service_name	Required string. Name of the service to check.

Returns:: A Python bool indicating whether the service exists.

get(service_name: str) → Service

Return a service resource by name.

Parameter	Description
service_name	Required string. Name of the service to retrieve.

Returns:: A Service object.

list() → Generator[Service, None, None]

Retrieves all registered video services from the server.

Returns:: A Python Generator of Service objects.

property session: EsriSession: Return the current session object.

property types: dict[str, Any]

Provides metadata for all the different services types and extensions that can be enabled on each service.

ArcGIS Video Server only reports Video Services.

property url: str: The current URL for the resource endpoint.

CreateResponse

pydantic model arcgis.gis.video.admin.services.model.CreateResponse

Response object returned by the create() method of the ServiceManager.

field item_id: str [Required]: The id of the service

field name: str [Required]: The name of the service

field success: bool [Required]: The result of the create request indicating if the service was created

PortalProperties

pydantic model arcgis.gis.video.admin.services.model.PortalProperties

Portal association details for a service.

field portal_items: List[PortalItem] [Required]: Associated items in the Portal.

Service

class arcgis.gis.video.admin.services.api.Service(url, session)

Bases: object

Represent a single administrative video service resource.

Objects of this type are returned by the get or list methods.

delete(skip_portal_delete: bool) → bool

Delete this service.

Parameter	Description
skip_portal_delete	Optional bool. When `True`, the backing Portal item is not deleted. Default is `False`.

Returns:: A Python bool indicating whether the service was successfully deleted.

property info: BasicServiceInfo

Return service metadata for this video service resource.

Returns:: BasicServiceInfo

property session: EsriSession: Return the current session object.

property url: str: The current URL

BasicServiceInfo

pydantic model arcgis.gis.video.admin.services.model.BasicServiceInfo

Basic metadata for an individual video service returned by the info property.

field description: str [Required]: If the chosen video service includes a description, it will be output as a string in the description property.

field extensions: List[str] [Required]: If any extensions were used to publish the service, they will be listed as part of the extensions property.

field portal_properties: PortalProperties [Required]: Linked Portal item metadata for the service.

field service_name: str [Required]: The name of the selected video service.

field type: str [Required]: The type of service. For ArcGIS Video Server, this will always appear as VideoServer.

PortalItem

pydantic model arcgis.gis.video.admin.services.model.PortalItem

Information for any associated item in the connected ArcGIS Portal.

field item_id: str [Required]: The ID of the portal item.

field type: str [Required]: The type of the portal item.

LayerInfo

pydantic model arcgis.gis.video.admin.services.model.LayerInfo

Extended metadata for a video layer hosted by a service.

field copyright_text: str [Required]: Any associated copyright text

field created: str [Required]: When the layer was created

field description: str [Required]: The description of the layer, if provided

field id: int [Required]: The id of the video layer

field name: str [Required]: The name of the video layer

field service_type: str [Required]: The type of the service (ONDEMAND or LIVESTREAM)

field source_file: str [Required]: The file used to create the layer if the type is ONDEMAND

field source_files_info: list [Required]: Further information for any associated source files

field supported_query_formats: bool [Required]: Formats supported by layer query operations, such as JSON or GeoJSON.

field supports_export_clip: bool [Required]: Indicates if a clip can be exported from this video layer

field supports_export_frameset: bool [Required]: Indicates if framesets can be exported from this video layer

field supports_mensuration: bool [Required]: Indicates if the video layer supports mensuration.

field supports_previews: bool [Required]: Indicates if the video layer supports previews.

SourceFileInfo

pydantic model arcgis.gis.video.admin.services.model.SourceFileInfo

Metadata describing a source file associated with a video layer.

field content_type: str [Required]: The source file’s content type

field id: int [Required]: The assigned id for the source file

field name: str [Required]: The source file name

field size: str [Required]: The size of the source file (in bytes)

Administrative System Management

SystemManager

class arcgis.gis.video.admin.system.api.SystemManager(url: str, session: EsriSession)

Bases: object

Manager object to access a collection of miscellaneous server-wide resources to get information on system properties, licensing details, config-store metadata, directories, web adaptors, and livestream protocol/port configuration.

Objects of this type are returned by the system property.

property config_store: dict[str, str]

Retrieve information on all the server’s configurations, typically including all resources such as machines, services and security rules. The config store is the authoritative site configuration repository used by all machines in the deployment.

Returns:: A Python dict descibing configuration information.

property directories: DirectoryManager

Retrieves an object to manage all the server directories.

Returns:: A DirectoryManager object.

property indexer: IndexManager

Return the index manager for status and reindex operations.

Returns:: A IndexManager object.

licenses(by_machine: bool) → dict[str, Any]

Return information about the current license level of Video Server and all extensions. The information is returned as a Python dict object. The by_machine parameter controls whether the license information is returned per machine.

Returns:: A Python dict describing license information.

property livestream: LivestreamManager

Provide access to a manager object for all livestream configuration and endpoint options.

Returns:: A LivestreamManager object.

property properties: dict[str, Any]: Retrieves a Python dict or sets the properties to a new SystemUpdateParameters object with Video Server system configuration properties.

property session: EsriSession: Return the current session object.

property url: str: The current resource endpoint for system resources.

property web_adaptors: WebAdaptorManager

Gets a manager object for the web adaptor(s) in the deployment.

Returns:: A WebAdaptorManager object.

SystemUpdateParameters

pydantic model arcgis.gis.video.admin.system.model.SystemUpdateParameters

Object that can be used to update system properties by creating a new instance and assigning it to the properties attribute of a SystemManager object.

Fields left as None are omitted from the update payload so existing server settings can remain unchanged.

field disableServicesDirectory: bool | None [Required]: Whether the public services directory UI is disabled.

field maxFileUploadSize: int | None [Required]: Maximum upload size allowed by the server, in megabytes.

field max_frame_count: int | None [Required]: Maximum frame count processed per request for relevant server workflows.

ReindexMode

class arcgis.gis.video.admin.system.model.ReindexMode(*values)

ALL = 'ALL'

COVERAGE = 'COVERAGE'

FOOTPRINTS = 'FOOTPRINTS'

SERVICE = 'SERVICE'

DirectoryManager

class arcgis.gis.video.admin.system.api.DirectoryManager(url: str, session: EsriSession)

Bases: object

Manager object for all the server directories. Objects of this type are returned by the directories property.

info(id: str) → DirectoryInformation

Return metadata for a single directory by ID.

Returns:: A Python DirectoryInformation object.

property list: list[DirectoryInformation]

Return registered directory definitions.

Returns:: A Python list of DirectoryInformation objects.

property session: EsriSession: Return the current session object.

property url: str: The current URL

DirectoryInformation

pydantic model arcgis.gis.video.admin.system.model.DirectoryInformation

Metadata for a registered system directory.

field id: str [Required]: The id of the directory

field name: str [Required]: The name of the directory

field path: str [Required]: The path to the directory

field type: str [Required]: The designated type for the directory contents

IndexManager

class arcgis.gis.video.admin.system.api.IndexManager(url: str, session: EsriSession)

Bases: object

Manage index status and reindex operations for the system. Objects of this type are returned by the indexer property.

reindex(mode: ReindexMode) → dict[str, str]

Start a reindex operation for the requested mode.

Parameter	Description
mode	Required `ReindexMode` enum.

Returns:: A Python dict indicating results of the operation.

property session: EsriSession: Return the current session object.

property status: dict[str, str]: Return current index status as a Python dict.

property url: str: The current URL

LivestreamManager

class arcgis.gis.video.admin.system.api.LivestreamManager(url: str, session: EsriSession)

Bases: object

Manage livestream protocol and port settings. Objects of this class are not created directly, but are returned by the livestream property.

property client_mode_protocols: ClientModeProtocols: Provide client playback protocol enablement flags as a ClientModeProtocols object.

property properties: LivestreamInformation

Return the combined livestream configuration document.

Returns:: dict[str, Any]

property server_mode_protocols: ServerModeProtocols: This resource displays whether WebRTC, HTTPS, Secure Reliable Transport (SRT), User Datagram Protocol (UPD), Real-Time Messaging Protocol (RTMP, RTMPS), and Real-Time Streaming Protocol (RTSP, RTSPS) livestreams are enabled or disabled. The attribute provides access to a ServerModeProtocols object.

property server_ports: ServerPorts: Retreives a ServerPorts object with configured ingest/listener ports for livestream protocols.

property session: EsriSession: Return the current session object.

set_client_mode_protocols(protocols: ClientModeProtocols) → dict[str, Any]

Sets whether HTTPS, Real-Time Messaging Protocol (RTMP, RTMPS), and Real-Time Streaming Protocol (RTSP, RTSPS) livestreams are enabled or disabled.

Returns:: dict[str, Any]

set_server_mode_protocols(protocols: ServerModeProtocols) → dict[str, Any]

Sets whether WebRTC, HTTPS, Secure Reliable Transport (SRT), User Datagram Protocol (UPD), Real-Time Messaging Protocol (RTMP, RTMPS), and Real-Time Streaming Protocol (RTSP, RTSPS) livestreams are enabled or disabled.

Returns:: dict[str, Any]

set_server_ports(ports: ServerPorts) → dict[str, Any]

Update livestream ingest/listener ports.

Returns:: dict[str, Any]

property url: str: The current URL

LivestreamInformation

pydantic model arcgis.gis.video.admin.system.model.LivestreamInformation

Combined livestream configuration information returned by the properties attribute of the LivestreamManager object.

field client_mode_protocols: ClientModeProtocols | None [Required]: Protocol enablement for client playback workflows.

field livestream_ports: ServerPorts | None [Required]: Configured ingest/listener ports for livestream protocols.

field server_mode_protocols: ServerModeProtocols | None [Required]: Protocol enablement for server-side ingest workflows.

ClientModeProtocols

pydantic model arcgis.gis.video.admin.system.model.ClientModeProtocols

Protocol enablement flags for client playback mode.

field https: bool | None [Required]: Indicates whether HTTPS streams are enabled.

field rtmp: bool | None [Required]: Indicates whether RTMP streams are enabled.

field rtmps: bool | None [Required]: Indicates whether RTMPS streams are enabled.

field rtsp: bool | None [Required]: Indicates whether RTSP streams are enabled.

field rtsps: bool | None [Required]: Indicates whether RTSPS streams are enabled.

ServerModeProtocols

pydantic model arcgis.gis.video.admin.system.model.ServerModeProtocols

Protocol enablement flags for livestream ingest in server mode.

field rtmp: bool | None [Required]: Indicates whether RTMP streams are allowed in Server Mode.

field rtmp_listen: bool | None [Required]: Indicates whether listening for RTMP streams is allowed in Server Mode.

field rtsp: bool | None [Required]: Indicates whether RTSP streams are allowed in Server Mode.

field rtsp_listen: bool | None [Required]: Indicates whether listening for RTSP streams is allowed in Server Mode.

field srt: bool | None [Required]: Indicates whether SRT streams are allowed in Server Mode.

field srt_listen: bool | None [Required]: Indicates whether listening for SRT streams is allowed in Server Mode.

field udp: bool | None [Required]: Indicates whether SRT streams are allowed in Server Mode.

field udp_listen: bool | None [Required]: Indicates whether listening for UDP streams is allowed in Server Mode.

ServerPorts

pydantic model arcgis.gis.video.admin.system.model.ServerPorts

Livestream listener port settings.

field range_max: int | None = 65535

The maximum SRT/UDP port value.

Constraints:

gt = 0

field range_min: int | None = 49152

The minimum SRT/UDP port value.

Constraints:

gt = 0

field rtmp_port: int | None = 1935

The default port for RTMP livestreams.

Constraints:

gt = 0

field rtsp_port: int | None = 554

The default port for RTSP livestreams.

Constraints:

gt = 0

WebAdaptor

class arcgis.gis.video.admin.system.api.WebAdaptor(url: str, session: EsriSession)

Bases: object

Represent a single registered ArcGIS Web Adaptor.

Web adaptors provide the external entry point and reverse-proxy layer for ArcGIS Video Server requests.

Objects of this class are not created directly, but are instead returned by the list() method.

property properties: dict[str, Any]: Return endpoint JSON properties.

property session: EsriSession: Return the current session object.

unregister() → dict[str, str]: Unregister this web adaptor from the site.

property url: str: The current URL

WebAdaptorManager

class arcgis.gis.video.admin.system.api.WebAdaptorManager(url: str, session: EsriSession)

Bases: object

Manage web adaptor resources for the video server site. Objects of this class are returned by the web_adaptors attribute of a SystemManager object.

property config: dict[str, str]

Get or set the shared web adaptor configuration.

Includes settings such as shared key material used by registered web adaptors. Set the configuration by assigning a dictionary to this property.

Parameter	Description
config	Required dict. The configuration items to be updated for this web adaptor. Always include the web adaptor’s sharedkey attribute.

list() → list

Returns a list of all registered web adaptors.

Returns:: A Python list of WebAdaptor objects.

property properties: dict[str, Any]: Return web adaptor collection metadata.

property session: EsriSession: Return the current session object.

property url: str: The current URL

Administrative Data Management

DataManager

class arcgis.gis.video.admin.data.api.DataManager(url: str, session: EsriSession)

Bases: object

Manage datastore registration and validation for Video Server. Data items describe connections to folders, cloud stores, object stores, and relational stores used by ArcGIS Video Server services. The class intializes an object created using the Data resource of a Video Server site.

Objects of this class are not initialized directy, but instead are accessed using the data property on an AdminVideoServer instance.

Example: Access the data manager for a Video Server instance:

from arcgis.gis import GIS
gis = GIS(profile="your_enterprise_admin_profile")

vid_server = gis.admin.servers.get(function="VideoServer")[0]
vid_admin = vid_server.admin
data_mgr = vid_admin.data

Example: Chaining properties together to access the data manager:

from arcgis.gis import GIS
gis = GIS(profile="your_enterprise_admin_profile")

vid_admin = gis.admin.servers.get(function="VideoServer")[0].admin
data_mgr = vid_admin.data
data_mgr

Output:

< DataManager @ https://example.com:21443/arcgis/admin/video/data >

add_cloud_store(item_desc: CloudStoreItemDescription) → dict[str, Any]: Sends a CloudStoreItemDescription to register a cloud-store as a data item with the server’s datastore.

add_database(item_desc: NoSQLItemDescription) → dict[str, Any]: Sends a NoSQLItemDescription to register a nosql database as a data item with the server’s datastore.

add_folder(item_desc: FolderItemDescription) → dict[str, Any]: Sends a FolderItemDescription to register a folder as a data item with the server’s datastore.

add_object_store(item_desc: ObjectStoreItemDescription) → dict[str, Any]: Sends a ObjectStoreItemDescription to register an object-store as a data item with the server’s datastore.

configure() → dict[str, Any]: Registers any currently relevant data items in the ArcGIS Enterprise data stores with the Video Server data store.

property default_item: DataItem | None: Get or set the the default data item. With proper permissiions, you can assign a data item object to this property to set one.

find_items(search_params: DataItemSearchParams) → dict[str, str]

Search for registered data items, defining an optional DataItemSearchParams object to filter what is returned.

Returns:: A Python dictionary containing an items key whose value is a list of dictionary objects providing properties of each registered data item.

Example: Finding data items

from arcgis.gis import GIS
from arcgis.gis.video.admin.data.model import DataItemSearchParams

gis = GIS(profile="your_enterprise_admin_profile")
vid_server = gis.admin.servers.get(function="VideoServer")[0]
vid_admin = vid_server.admin

data_mgr = vid_admin.data

dsearch_params = DataItemSearchParams(
    types="nosql"
)

data_items = data_mgr.find_items(search_params=dsearch_params)
print(data_items)

Output:

{
    "items": [
        {
            'path': '/nosqlDatabases/VideoDataStore_queue_P8KS6bwY',
            'name': 'pwDDgfqR',
            'id': '8fae8142-....-....-....-69202e52c315',
            'type': 'nosql',
            'info': {'hostname': 'EXAMPLE.COM',
                'password': 'v2...t_ifHJ-kE....-Ku_M.',
                'port': 45671,
                'username': '5pwr8oxn'
        }
    ]
}

property items: Generator[DataItem, None, None]

Retrieves a Python Generator of registered DataItem objects on the server

Returns:: A Python Generator for iterating over the objects of type DataItem.

Example: Get the list of registered data items for VideoServer

from arcgis.gis import GIS
gis = GIS(profile="your_enterprise_admin_profile")

vid_server = gis.admin.servers.get(function="VideoServer")[0]

data_mgr = vid_server.admin.data

item_generator = data_mgr.items
for data_item in item_generator:
    print(f"{data_item.properties['type']:15} {type(data_item)}")

Output:

nosql            <class 'arcgis.gis.video.admin.data.api.DataItem'>
folder           <class 'arcgis.gis.video.admin.data.api.DataItem'>
folder           <class 'arcgis.gis.video.admin.data.api.DataItem'>

register(item_desc: NoSQLItemDescription | FolderItemDescription | CloudStoreItemDescription | ObjectStoreItemDescription | dict[str, Any]) → dict[str, Any]

Registers a new DataItem with the server’s data store by submitting one of the following instances for the the item_desc argument:

FolderItemDescription
CloudStoreItemDescription
ObjectStoreItemDescription
NoSQLItemDescription

The method sends the argument as a JSONencoded request to the server.

property session: EsriSession: Return the current session object.

synchronize_data_stores() → dict[str, Any]

Verfies that the connectivity for all registered data items are accessible to all server nodes in the site and can used within the server’s data store.

Returns:: A Python dictionary containing a status key indicating success or failure of the operation.

property url: str: The resource endpoint for managing the data holdings of the Video Server server.

validate_data_item(item_desc: dict[str, str]) → dict[str, Any]

Checks to ensure that the key-value pairs representing the definition of a data item are valid.

Verifies that the path or connection details are reachable from all site machines before registration.

DataItem

class arcgis.gis.video.admin.data.api.DataItem(url: str, session: EsriSession)

Bases: object

Represent a single registered data item resource.

Instances provide item metadata, machine-level validation resources, and item unregister support.

Objects of this class are not initialized directly; it is recommended to retrieve them using the items property of the DataManager.

Example: retrieve DataItem objects from DataManager.items

from arcgis.gis import GIS

gis = GIS(profile="your_enterprise_admin_profile")
vid_server = gis.admin.servers.get(function="VideoServer")[0]
vid_admin = vid_server.admin

data_mgr = vid_admin.data

data_item_list = list(data_mgr.items)
data_item_list

Output:

[< DataItem @ https://EXAMPLE.COM:21443/arcgis/admin/data/items/c8900a422f9b5e9141194a4d9146c584 >,
 < DataItem @ https://EXAMPLE.COM:21443/arcgis/admin/data/items/75eaee91-8f4a-42e3-8f76-ae96291e5379 >,
 < DataItem @ https://EXAMPLE.COM:21443/arcgis/admin/data/items/9eaa9491-f888-4af7-85b1-68802e44c311 >]

delete(force: bool) → dict[str, Any]: Unregisters this data item from the server’s data store.

property machines: Generator[Machine, None, None]

Retrieves a Python Generator for iterating over the machine resources associated with this data item.

Returns:: A Python Generator of machine objects.

property properties: dict[str, Any]: Retrieves a Python dictionary containing information about the DataItem, including its type, server path, name, and id value.

property session: EsriSession: Return the current EsriSession object.

property url: str: The resource endpoint for the registered data item.

Machine

class arcgis.gis.video.admin.data.api.Machine(url: str, session: EsriSession)

Bases: object

Represent a machine resource specific to a DataItem registered with the data store.

property properties: dict[str, Any]: Provides a Python dictionary whose key-value pairs contain information about the mahine resource, including name and configuration state.

property session: EsriSession: Return the current arcgis.auth.api.EsriSession object.

property url: str: The specific URL endpoint resource for this object.

validate() → dict[str, Any]: Checks whether the machine’s connectivity with the parent data item is valid.

DataItemSearchParams

pydantic model arcgis.gis.video.admin.data.model.DataItemSearchParams

Objects of this class are accepted by the search_params argument of the find_items() method.

Example: Searching for registered nosql data items

from arcgis.gis import GIS
from arcgis.gis.video.admin.data import DataItemSearchParams, DataItemType

gis = GIS(profile="your_enterprise_admin_profile")
vid_server = gis.admin.servers.get(function="VideoServer")[0]
vid_admin = vid_server.admin

data_mgr = vid_admin.data

search_terms = DataItemSearchParams(types=DataItemType.NOSQL)
data_items = data_mgr.find_items(search_params=search_terms)
data_items

Output example:

{'items': [{'path': '/nosqlDatabases/VideoDataStore_queue_Abdqr5fe',
            'name': 'Zmwmak4x',
            'id': '361c2390-4b76-419e-a4c5-cddfd23404ad',
            'type': 'nosql',
            'info': {
                'hostname': '10.0.0.xxx',
                'password': 'v2Cr..._tF8i6...seWaSdc-DT...kY.',
                'port': 4xxx1,
                'username': 'l4ip4coq'
            }
           }
          ]
}

field id: str | None = None: The ID of the data item

field managed: bool | None = None: Whether or not the items to be returned are managed by the system.

field types: str | DataItemType | None = None: Restrict the returned items to the specific type indicated.

DataItemDescription

pydantic model arcgis.gis.video.admin.data.model.DataItemDescription

Base payload for registering a data item with ArcGIS Video Server.

field path: str [Required]: The unique administrative path used to identify the registered data item.

field type: DataItemType [Required]: The registered data item type.

FileSystemInformation

pydantic model arcgis.gis.video.admin.data.model.FileSystemInformation

Connection details for a folder or file share data item.

field connection_string: str | None = None: Legacy JSON-string connection payload used by older folder-file-share request shapes.

field connection_type: str | None = None: Legacy folder-file-share connection type value used by older request shapes.

field data_store_connection_type: str [Required]: How the publisher and server relate to the same data, such as shared or replicated.

field host_name: str | None = None: Optional publisher host name used for replicated local-path folder registrations.

field path: str [Required]: The path to the folder as seen by ArcGIS Video Server.

CloudStoreConnectionString

pydantic model arcgis.gis.video.admin.data.model.CloudStoreConnectionString

Structured view of the JSON connectionString value used by cloud store registrations.

field access_key_id: str | None = None: Access key identifier for S3-compatible, Google, or Alibaba object storage.

field account_endpoint: str | None = None: Azure storage account endpoint suffix or host.

field account_key: str | None = None: Shared key used for Azure account-key authentication.

field account_name: str | None = None: Azure storage account name.

field authority_host: str | None = None: Authority host used during service principal authentication.

field client_id: str | None = None: Client identifier for service principal authentication.

field client_secret: str | None = None: Client secret for service principal authentication.

field credential_type: str | None = None: Authentication mode used for the cloud store connection.

field default_endpoints_protocol: str | None = None: Protocol used when constructing storage service endpoints, typically https.

field managed_identity_client_id: str | None = None: Client identifier for user-assigned managed identity authentication.

field region: str | None = None: Cloud region associated with the storage service endpoint.

field region_endpoint_url: str | None = None: Regional or private endpoint hostname for the cloud storage service.

field sas_token: str | None = None: Shared access signature token used for Azure SAS authentication.

field secret_access_key: str | None = None: Secret access key for S3-compatible, Google, or Alibaba object storage.

field tenant_id: str | None = None: Microsoft Entra tenant identifier for service principal authentication.

CloudStoreInformation

pydantic model arcgis.gis.video.admin.data.model.CloudStoreInformation

Connection details for a cloudStore data item.

field connection_string: CloudStoreConnectionString | str [Required]: Cloud store connection details, typically supplied as a JSON-string payload by the REST API.

field is_managed: bool | None = None: Indicates whether the cloud store is managed exclusively by the server.

field object_store: str [Required]: Bucket or container name, optionally including a subfolder path.

CloudStoreItemDescription

pydantic model arcgis.gis.video.admin.data.model.CloudStoreItemDescription

field info: CloudStoreInformation [Required]: Connection details for the cloud store registration.

field provider: str [Required]: Cloud provider name, such as amazon, azure, google, or Alibaba.

field system_managed: bool | None = None: Indicates whether the backing store is managed by the wider ArcGIS Enterprise deployment.

field type: Literal[DataItemType.HOSTEDDATASTORE] = DataItemType.HOSTEDDATASTORE: Identifies the payload as a cloud store data item.

NoSQLInformation

pydantic model arcgis.gis.video.admin.data.model.NoSQLInformation

Connection details for a nosql data item such as an enterprise-managed store or queue store.

field connection_string: str | None = None: Connection string used by the server to connect to the nosql store.

field hostname: str | None = None: Host name for queue-style nosql store definitions.

field password: str | None = None: Password for queue-style nosql store definitions.

field port: int | None = None: Port for queue-style nosql store definitions.

field username: str | None = None: User name for queue-style nosql store definitions.

NoSQLItemDescription

pydantic model arcgis.gis.video.admin.data.model.NoSQLItemDescription

field child_items: list[Any] | None = None: Optional child items returned by the admin API for hierarchical data item listings.

field id: str | None = None: Optional identifier returned for an existing registered nosql data item.

field info: NoSQLInformation [Required]: Connection details for the nosql store registration.

field provider: str | None = None: Provider name for the nosql store implementation.

field type: Literal[DataItemType.NOSQL] = DataItemType.NOSQL: Identifies the payload as a nosql data item.

ObjectStoreMachine

pydantic model arcgis.gis.video.admin.data.model.ObjectStoreMachine

Minimal object store machine metadata returned by enterprise-managed object store definitions.

field name: str | None = None: Machine name participating in the object store deployment.

ObjectStoreInformation

pydantic model arcgis.gis.video.admin.data.model.ObjectStoreInformation

Connection and deployment details for an objectStore data item.

field connection_string: str [Required]: Connection string used by ArcGIS to connect to the object store.

field datastore_name: str [Required]: Name assigned to the object store deployment in ArcGIS Enterprise.

field ds_feature: str [Required]: Datastore feature designation for the registration, typically objectStore.

field implementation: str [Required]: Backing object store implementation, such as Ozone.

field machines: list[ObjectStoreMachine] | None = None: Optional machine metadata for object stores backed by ArcGIS Data Store.

field object_store: str [Required]: Registered object store identifier, bucket, or container name.

ObjectStoreItemDescription

pydantic model arcgis.gis.video.admin.data.model.ObjectStoreItemDescription

field child_items: list[Any] | None = None: Optional child items returned by the admin API for hierarchical data item listings.

field id: str | None = None: Optional identifier returned for an existing registered object store.

field info: ObjectStoreInformation [Required]: Connection and deployment details for the object store.

field provider: str | None = None: Provider name for the object store implementation.

field type: Literal[DataItemType.OBJECTSTORE] = DataItemType.OBJECTSTORE: Identifies the payload as an object store data item.

FolderItemDescription

pydantic model arcgis.gis.video.admin.data.model.FolderItemDescription

field client_path: str | None = None: Optional publisher-visible path when the folder is replicated rather than shared.

field info: FileSystemInformation [Required]: Server-side file system connection details for the folder item.

field type: Literal[DataItemType.FILESYSTEM] = DataItemType.FILESYSTEM: Identifies the payload as a folder data item.

DataItemType

class arcgis.gis.video.admin.data.model.DataItemType(*values)

Enumeration of supported DataItem types to register as a holding of the data store. An element of this enumration should be entered as the types argument when initializing a DataItemSearchParams object.

FILESYSTEM = 'folder'

HOSTEDDATASTORE = 'cloudStore'

NOSQL = 'nosql'

OBJECTSTORE = 'objectStore'

Administrative Machine Management

MachineManager

class arcgis.gis.video.admin.machines.api.MachineManager(url: str, session: EsriSession)

Bases: object

An object for managing all the machines within the Video Server site. The collection represents site compute capacity and machine-level administration resources.

list() → Iterable[Machine]

Return all Machine object resources for all registered machines.

Returns:: A Python list of Machine objects.

property properties: dict[str, Any]: Reports various machine collection metadata, including configuration state, machine name, and other relevant information in a Python dict object.

property session: EsriSession: Return the current session object.

property url: str: The current URL of the machines resoure endpoint.

Machine

class arcgis.gis.video.admin.machines.api.Machine(url: str, session: EsriSession)

Bases: object

Represent a single machine resource, including access to information such as machine settings, hardware details, SSL certificate operations, and GPU tooling access.

Objects of this class are not meant to be created directly, but are returned by the list method.

create_self_signed_cert(cert_params: SelfSignedCertificateParameters) → dict[str, Any]

Generate a self-signed SSL certificate for this machine.

The certificate is stored in the machine keystore and is intended primarily for development or staging use.

Parameter	Description
cert_params	Required `SelfSignedCertificateParameters` object containing the desired self-signed certificate parameters.

Returns:: A Python dictionary with a status key indicating success or failure of the operation.

delete_certificate(certificate: str) → dict[str, Any]

Deletes a SSL certificate using the certificate alias.

Parameter	Description
certificate	Required string. The name of the certificate to delete

Returns:: A Python string stating “success” or error message.

edit(edit_params: MachineEditParameters) → dict

Make changes to the configurable machine settings. This operation may trigger a server restart depending on changed settings.

Argument	Description
edit_params	Required `MachineEditParameters` object containing the desired machine settings to update.

Returns:: A Python dictionary object.

export_certificate(certificate: str) → bytes

Downloads an SSL certificate. The file returned by the server is an X.509 certificate. The downloaded certificate can then be imported into a client that is making HTTP requests.

Parameter	Description
certificate	Required string. The name of the certificate in the key store.

Returns:: The SSL certificate object (bytes).

generate_CSR(certificate: str) → dict[str, Any]

Generates a certificate signing request (CSR) for a self-signed certificate. A CSR is required by a CA to create a digitally signed version of your certificate. Supply the certificate object that was created with method ssl_certificate.

Parameter	Description
certificate	Required string. The name of the certificate in the key store.

Returns:: A Python dictionary object with the CSR.

property gpu: GPUManager

An object for managing GPU operations of the machine.

Returns:: A GPUManager object.

property hardware: dict[str, Any]

Return the current hardware information for this machine.

Returns:: A Python dictionary object describing the machine hardware. See the Video Server hardware documentation for full detailed response example.

import_existing_server_certificate(alias: str, cert_password: str, cert_file: str) → dict[str, Any]

Imports an existing server certificate, stored in the PKCS #12 format, into the keystore. If the certificate is a CA-signed certificate, you must first import the CA root or intermediate certificate using the importRootCertificate operation.

Parameter	Description
alias	Required string. A unique name for the certificate that easily identifies it.
cert_password	Required string. The password to unlock the file containing the certificate.
cert_file	Required string. The multi-part POST parameter containing the certificate file.

Returns:: A boolean indicating success (True) or failure (False).

import_root_certificate(alias: str, root_CA_certificate: str) → dict[str, Any]

Imports a certificate authority’s (CA) root and intermediate certificates into the keystore.

To create a production quality CA-signed certificate, you need to add the CA’s certificates into the keystore that enables the SSL mechanism to trust the CA (and the certificates it is signed). While most of the popular CA’s certificates are already available in the keystore, you can use this operation if you have a custom CA or specific intermediate certificates.

Parameter	Description
alias	Required string. The name of the certificate.
root_CA_certificate	Required string. The multi-part POST parameter containing the certificate file.

Returns:: A boolean indicating success (True) or failure (False).

import_signed_certificate(certificate: str, ca_signed_certificate: str) → dict[str, Any]

Imports a certificate authority (CA)-signed SSL certificate into the key store.

Parameter	Description
certificate	Required string. The name of the certificate in the key store.
ca_signed_certificate	Required string. The multi-part POST parameter containing the signed certificate file.

Returns:: A boolean indicating success (True) or failure (False).

property properties: dict[str, Any]: Return machine properties from the machine detail endpoint.

property session: EsriSession: Return the current session object.

ssl_certificate(certificate: str) → dict[str, Any]

Gets a single self-signed certificate object.

Note

Even though a self-signed certificate can be used to enable SSL, it is recommended that you use a self-signed certificate only on staging or development servers.

Parameter	Description
certificate	Required string. The name of the certificate in the key store to grab information from.

Returns:: A Python dictionary object describing the certificate.

property ssl_certificates: dict[str, Any]: Gets the list of all the certificates (self-signed and CA-signed) created for the server machine. The server securely stores these certificates inside a key store within the configuration store.

property tool_status: dict[str, Any]

Report on machine diagnostics, particularly useful to run if is not clear whether a specific function of the site is running.

Returns:: A Python dictionary object describing. See the Tool Status response properties for full details.

unregister() → dict[str, Any]

Unregister this machine from the site.

After unregistering, the machine no longer participates in service execution for this deployment.

Returns:: A Python dictionary with a status key indicating success or failure of the operation.

property url: str: The current URL endpoint for this machine resource.

GPUManager

class arcgis.gis.video.admin.machines.api.GPUManager(url: str, session: EsriSession)

Bases: object

Object for managing the GPU limit operations for a machine. This object is not meant to be created directly, but is returned by the gpu property of a Machine object.

check() → dict[str, Any]

Run the GPU limit check tool on this machine.

Returns:: A Python dictionary object with the server response.

edit(limit: int) → dict[str, Any]

Manually set the GPU limit for this machine.

Parameter	Description
limit	The desired GPU Limit, as an integer. This value should reflect the actual number of available GPUs in an environment.

Returns:: Parsed JSON response when available. Some server versions return an empty 200 body after applying the update; in that case this method returns {"success": True}.

property info: GPULimitInfo

Return current GPU limit information.

Returns:: A Python dictionary object with GPU limit information.

property properties: dict[str, Any]: Return GPU manager endpoint metadata.

property session: EsriSession: Return the current session object.

property url: str: The current URL

GPULimitInfo

pydantic model arcgis.gis.video.admin.machines.model.GPULimitInfo

GPU limit status returned by machine GPU endpoints.

field lastExecuted: int [Required]: When the limit check was last executed on the machine.

field limit: int [Required]: The number of GPUs set for the video server to use.

SelfSignedCertificateParameters

pydantic model arcgis.gis.video.admin.machines.model.SelfSignedCertificateParameters

Parameters used to generate a self-signed certificate for a machine.

field alias: str [Required]: A unique name that easily identifies the certificate.

field city: str [Required]: The name of the city or locality, for example, Redlands.

field common_name: str [Required]: Use the domain name of your server name as the common name. If your server will be accessed on the Internet through the URL https://www.Video.com:11443/arcgis/, use www.Videoserver.com as the common name. If your server will only be accessible on your local area network (LAN) through the URL https://Videoserver.domain.com:11443/arcgis/, use Videoserver as the common name.

field country: str [Required]: The abbreviated code for your country, for example, US.

field keyalg: str | None [Required]: The algorithm used to generate the key pairs. The default is RSA.

field keysize: int [Required]

Specifies the size in bits to use when generating the cryptographic keys used to create the certificate. The larger the key size, the harder it is to break the encryption; however, the time to decrypt encrypted data increases with key size. For DSA, the key size can be between 512 and 1,024. For RSA, the recommended key size is 2,048 or greater.

Constraints:

gt = 0

field org_unit: str [Required]: The name of your organizational unit, for example, GIS Department.

field organization: str [Required]: The name of your organization, for example, Esri.

field san: str | None [Required]: The subject alternative name (SAN) is an optional parameter that defines alternatives to the common name (CN) specified in the SSL certificate. There cannot be any spaces in the SAN parameter value. If no SAN is defined, a website can only be accessed (without SSL certificate errors) by using the common name in the URL. If a SAN is defined and a DNS name is present, the website can only be accessed by what is listed in the SAN. Multiple DNS names can be specified if desired. For example, the URLs https://www.esri.com, https://esri, and https://10.60.1.16 can be used to access the same site if the SSL certificate is created using the following SAN parameter value: DNS:www.esri.com,DNS:esri,IP:10.60.1.16

field sigalg: str | None [Required]: Use the default (SHA1withRSA). If your organization has specific security restrictions, then one of the following algorithms can be used for DSA: SHA256withRSA, SHA384withRSA, SHA512withRSA, SHA1withDSA.

field state: str [Required]: The full name of your state or province, for example, California.

field validity: int = 90

The total time in days during which this certificate will be valid, for example, 365. The default is 90.

Constraints:

gt = 0

MachineEditParameters

pydantic model arcgis.gis.video.admin.machines.model.MachineEditParameters

Editable machine settings posted to /admin/machines/{machine}/edit.

field admin_url: str | None [Required]: The URL where the administrator API is running on the server machine.

field cert_alias: str | None [Required]: The alias of the web server SSL certificate.

field max_heap: int | None [Required]

Defines the maximum file size (in MB) that the web server’s Java process can send to ArcGIS Video Server. The default value is -1 MB, meaning the web server will use one-fourth of the available system memory as the maximum heap size. If you are observing a server performance impact and you have additional system memory, you can increase the heap size of the web server by updating this value from the default of -1 MB to an appropriate value. Note that doing so will potentially increase the amount of memory assigned to ArcGIS Video Server processes by your operating system. If you have a multiple-machine site, this property should be identical on each of your machines.

Constraints:

ge = -1

field num_processors: int | None [Required]

Defines the number of video processors available on ArcGIS Video Server. The default value is 1 and can be increased if needed. For most users, 1 will be sufficient.

Constraints:

ge = 1

Dataclasses

Upload

pydantic model arcgis.gis.video.admin.model.Upload

Metadata describing an uploaded file resource.

field committed: bool [Required]: Whether the upload has been finalized and committed by the server.

field content_type: str [Required]: The type of data contained in the upload file.

field date: int | None [Required]: The date when the upload was added to the server.

field description: str | None = None: A description of the upload, if provided.

field file_id: str [Required]: System generated id for the uploaded file.

field file_name: str [Required]: The file name for the upload.

field owner: str [Required]: The owner of the upload.

SiteMode

class arcgis.gis.video.admin.model.SiteMode(*values)

Site mode values used by the admin /mode operation.

READ_ONLY blocks most publishing and administrative edits while existing services continue serving content.

EDITABLE = 'EDITABLE'

READ_ONLY = 'READ_ONLY'