0
# Subscription and Features
1

2
Subscription operations and Azure feature management including feature registration, tenant-level operations, and subscription metadata management. These clients provide capabilities for managing Azure subscriptions and controlling access to preview features.
3

4
## Capabilities
5

6
### Subscription Management
7

8
Access subscription information, list available subscriptions, and manage subscription-level metadata.
9

10
```python { .api }
11
class SubscriptionsOperations:
12
    def list_locations(
13
        self, 
14
        subscription_id: str, 
15
        **kwargs
16
    ) -> Iterable[Location]:
17
        """
18
        List available locations for a subscription.
19
        
20
        Args:
21
            subscription_id (str): Subscription ID
22
            
23
        Returns:
24
            Iterable[Location]: Iterator of available locations
25
        """
26

27
    def get(self, subscription_id: str, **kwargs) -> Subscription:
28
        """
29
        Get subscription details.
30
        
31
        Args:
32
            subscription_id (str): Subscription ID
33
            
34
        Returns:
35
            Subscription: Subscription information
36
        """
37

38
    def list(self, **kwargs) -> Iterable[Subscription]:
39
        """
40
        List all subscriptions for the authenticated user.
41
        
42
        Returns:
43
            Iterable[Subscription]: Iterator of subscriptions
44
        """
45

46
    def check_zone_peers(
47
        self,
48
        subscription_id: str,
49
        parameters: CheckZonePeersRequest,
50
        **kwargs
51
    ) -> CheckZonePeersResult:
52
        """
53
        Check availability zone peers for a subscription.
54
        
55
        Args:
56
            subscription_id (str): Subscription ID
57
            parameters (CheckZonePeersRequest): Zone peer check parameters
58
            
59
        Returns:
60
            CheckZonePeersResult: Zone peer information
61
        """
62
```
63

64
### Tenant Operations
65

66
Manage tenant-level operations and access tenant information.
67

68
```python { .api }
69
class TenantsOperations:
70
    def list(self, **kwargs) -> Iterable[TenantIdDescription]:
71
        """
72
        List tenants for the authenticated user.
73
        
74
        Returns:
75
            Iterable[TenantIdDescription]: Iterator of tenant information
76
        """
77
```
78

79
### Feature Registration
80

81
Register and manage Azure preview features for subscriptions.
82

83
```python { .api }
84
class FeaturesOperations:
85
    def list(
86
        self, 
87
        resource_provider_namespace: str, 
88
        **kwargs
89
    ) -> Iterable[FeatureResult]:
90
        """
91
        List features for a resource provider.
92
        
93
        Args:
94
            resource_provider_namespace (str): Resource provider namespace
95
            
96
        Returns:
97
            Iterable[FeatureResult]: Iterator of features
98
        """
99

100
    def list_all(self, **kwargs) -> Iterable[FeatureResult]:
101
        """
102
        List all features across all resource providers.
103
        
104
        Returns:
105
            Iterable[FeatureResult]: Iterator of all features
106
        """
107

108
    def get(
109
        self,
110
        resource_provider_namespace: str,
111
        feature_name: str,
112
        **kwargs
113
    ) -> FeatureResult:
114
        """
115
        Get feature information.
116
        
117
        Args:
118
            resource_provider_namespace (str): Resource provider namespace
119
            feature_name (str): Feature name
120
            
121
        Returns:
122
            FeatureResult: Feature details
123
        """
124

125
    def register(
126
        self,
127
        resource_provider_namespace: str,
128
        feature_name: str,
129
        **kwargs
130
    ) -> FeatureResult:
131
        """
132
        Register a feature for the subscription.
133
        
134
        Args:
135
            resource_provider_namespace (str): Resource provider namespace
136
            feature_name (str): Feature name
137
            
138
        Returns:
139
            FeatureResult: Registration result
140
        """
141

142
    def unregister(
143
        self,
144
        resource_provider_namespace: str,
145
        feature_name: str,
146
        **kwargs
147
    ) -> FeatureResult:
148
        """
149
        Unregister a feature for the subscription.
150
        
151
        Returns:
152
            FeatureResult: Unregistration result
153
        """
154
```
155

156
### Subscription Feature Registrations
157

158
Manage subscription-level feature registrations with enhanced capabilities.
159

160
```python { .api }
161
class SubscriptionFeatureRegistrationsOperations:
162
    def get(
163
        self,
164
        provider_namespace: str,
165
        feature_name: str,
166
        **kwargs
167
    ) -> SubscriptionFeatureRegistration:
168
        """
169
        Get subscription feature registration.
170
        
171
        Args:
172
            provider_namespace (str): Provider namespace
173
            feature_name (str): Feature name
174
            
175
        Returns:
176
            SubscriptionFeatureRegistration: Feature registration details
177
        """
178

179
    def create_or_update(
180
        self,
181
        provider_namespace: str,
182
        feature_name: str,
183
        **kwargs
184
    ) -> SubscriptionFeatureRegistration:
185
        """
186
        Create or update subscription feature registration.
187
        
188
        Args:
189
            provider_namespace (str): Provider namespace
190
            feature_name (str): Feature name
191
            
192
        Returns:
193
            SubscriptionFeatureRegistration: Registration result
194
        """
195

196
    def delete(
197
        self,
198
        provider_namespace: str,
199
        feature_name: str,
200
        **kwargs
201
    ) -> None:
202
        """Delete subscription feature registration."""
203

204
    def list_all_by_subscription(
205
        self, 
206
        **kwargs
207
    ) -> Iterable[SubscriptionFeatureRegistration]:
208
        """
209
        List all feature registrations for the subscription.
210
        
211
        Returns:
212
            Iterable[SubscriptionFeatureRegistration]: Iterator of registrations
213
        """
214

215
    def list_by_subscription(
216
        self,
217
        provider_namespace: str,
218
        **kwargs
219
    ) -> Iterable[SubscriptionFeatureRegistration]:
220
        """
221
        List feature registrations for a provider.
222
        
223
        Args:
224
            provider_namespace (str): Provider namespace
225
            
226
        Returns:
227
            Iterable[SubscriptionFeatureRegistration]: Iterator of registrations
228
        """
229
```
230

231
## Model Classes
232

233
```python { .api }
234
class Subscription:
235
    """Subscription information."""
236
    id: str
237
    subscription_id: str
238
    tenant_id: str
239
    display_name: str
240
    state: SubscriptionState
241
    subscription_policies: SubscriptionPolicies
242
    authorization_source: str
243
    managed_by_tenants: List[ManagedByTenant]
244
    tags: Dict[str, str]
245

246
class SubscriptionPolicies:
247
    """Subscription policies."""
248
    location_placement_id: str
249
    quota_id: str
250
    spending_limit: SpendingLimit
251

252
class Location:
253
    """Azure location information."""
254
    id: str
255
    subscription_id: str
256
    name: str
257
    type: str
258
    display_name: str
259
    latitude: str
260
    longitude: str
261
    regional_display_name: str
262
    metadata: LocationMetadata
263
    availability_zone_mappings: List[AvailabilityZoneMapping]
264

265
class TenantIdDescription:
266
    """Tenant information."""
267
    id: str
268
    tenant_id: str
269
    display_name: str
270
    domains: List[str]
271
    country: str
272
    country_code: str
273
    tenant_category: TenantCategory
274
    default_domain: str
275
    tenant_type: str
276

277
class FeatureResult:
278
    """Feature information."""
279
    name: str
280
    properties: FeatureProperties
281
    id: str
282
    type: str
283

284
class FeatureProperties:
285
    """Feature properties."""
286
    state: str
287
    display_name: str
288
    description: str
289

290
class SubscriptionFeatureRegistration:
291
    """Subscription feature registration."""
292
    id: str
293
    name: str
294
    type: str
295
    properties: SubscriptionFeatureRegistrationProperties
296

297
class SubscriptionFeatureRegistrationProperties:
298
    """Subscription feature registration properties."""
299
    tenant_id: str
300
    subscription_id: str
301
    feature_name: str
302
    display_name: str
303
    provider_namespace: str
304
    state: SubscriptionFeatureRegistrationState
305
    authorization_profile: AuthorizationProfile
306
    metadata: Dict[str, str]
307
    should_feature_display_in_portal: bool
308
    description: str
309
    documentation_link: str
310
    approval_type: SubscriptionFeatureRegistrationApprovalType
311

312
class AuthorizationProfile:
313
    """Authorization profile for feature registration."""
314
    requested_time: datetime
315
    requester: str
316
    requester_object_id: str
317
    approved_time: datetime
318
    approver: str
319
    approval_type: SubscriptionFeatureRegistrationApprovalType
320

321
class CheckZonePeersRequest:
322
    """Zone peers check request."""
323
    location: str
324
    subscription_ids: List[str]
325

326
class CheckZonePeersResult:
327
    """Zone peers check result."""
328
    subscription_id: str
329
    location: str
330
    availability_zone_peers: List[AvailabilityZonePeers]
331

332
class AvailabilityZonePeers:
333
    """Availability zone peer information."""
334
    availability_zone: str
335
    peers: List[Peer]
336
```
337

338
## Enums
339

340
```python { .api }
341
class SubscriptionState(str, Enum):
342
    """Subscription states."""
343
    ENABLED = "Enabled"
344
    WARNED = "Warned"
345
    PAST_DUE = "PastDue"
346
    DISABLED = "Disabled"
347
    DELETED = "Deleted"
348

349
class SpendingLimit(str, Enum):
350
    """Spending limit states."""
351
    ON = "On"
352
    OFF = "Off"
353
    CURRENT_PERIOD_OFF = "CurrentPeriodOff"
354

355
class TenantCategory(str, Enum):
356
    """Tenant categories."""
357
    HOME = "Home"
358
    PROJECTED_BY = "ProjectedBy"
359
    MANAGED_BY = "ManagedBy"
360

361
class SubscriptionFeatureRegistrationState(str, Enum):
362
    """Feature registration states."""
363
    NOT_SPECIFIED = "NotSpecified"
364
    NOT_REGISTERED = "NotRegistered"
365
    PENDING = "Pending"
366
    REGISTERING = "Registering"  
367
    REGISTERED = "Registered"
368
    UNREGISTERING = "Unregistering"
369
    UNREGISTERED = "Unregistered"
370

371
class SubscriptionFeatureRegistrationApprovalType(str, Enum):
372
    """Feature registration approval types."""
373
    NOT_SPECIFIED = "NotSpecified"
374
    REQUIRED = "Required"
375
    AUTO_APPROVAL = "AutoApproval"
376
```
377

378
## Usage Examples
379

380
**Managing Subscriptions and Locations:**
381

382
```python
383
from azure.identity import DefaultAzureCredential
384
from azure.mgmt.resource import SubscriptionClient
385

386
# Create subscription client (no subscription_id needed)
387
credential = DefaultAzureCredential()
388
sub_client = SubscriptionClient(credential=credential)
389

390
# List all accessible subscriptions
391
print("Available subscriptions:")
392
for subscription in sub_client.subscriptions.list():
393
    print(f"  {subscription.display_name}: {subscription.subscription_id}")
394

395
# Get details for a specific subscription
396
subscription = sub_client.subscriptions.get("your-subscription-id")
397
print(f"Subscription: {subscription.display_name}")
398
print(f"State: {subscription.state}")
399
print(f"Tenant ID: {subscription.tenant_id}")
400

401
# List available locations
402
locations = sub_client.subscriptions.list_locations("your-subscription-id")
403
for location in locations:
404
    print(f"Location: {location.display_name} ({location.name})")
405
```
406

407
**Managing Azure Preview Features:**
408

409
```python
410
from azure.identity import DefaultAzureCredential
411
from azure.mgmt.resource import FeatureClient
412

413
credential = DefaultAzureCredential()
414
feature_client = FeatureClient(
415
    credential=credential,
416
    subscription_id="your-subscription-id"
417
)
418

419
# List all features for a resource provider
420
features = feature_client.features.list("Microsoft.Compute")
421
for feature in features:
422
    print(f"Feature: {feature.name}")
423
    print(f"  State: {feature.properties.state}")
424
    print(f"  Display Name: {feature.properties.display_name}")
425

426
# Register a preview feature
427
registration = feature_client.features.register(
428
    resource_provider_namespace="Microsoft.Compute",
429
    feature_name="SomePreviewFeature"
430
)
431
print(f"Registration state: {registration.properties.state}")
432

433
# Check feature registration status
434
feature = feature_client.features.get(
435
    resource_provider_namespace="Microsoft.Compute",
436
    feature_name="SomePreviewFeature"
437
)
438
print(f"Current state: {feature.properties.state}")
439
```
440

441
**Working with Subscription Feature Registrations:**
442

443
```python
444
# List all feature registrations for the subscription
445
registrations = feature_client.subscription_feature_registrations.list_all_by_subscription()
446
for registration in registrations:
447
    print(f"Feature: {registration.properties.feature_name}")
448
    print(f"  Provider: {registration.properties.provider_namespace}")
449
    print(f"  State: {registration.properties.state}")
450
    print(f"  Approval Type: {registration.properties.approval_type}")
451

452
# Create a subscription feature registration
453
registration = feature_client.subscription_feature_registrations.create_or_update(
454
    provider_namespace="Microsoft.Storage",
455
    feature_name="AllowBlobPublicAccess"
456
)
457
```