CheckmarxPythonSDK 1.6.4__tar.gz → 1.6.6__tar.gz

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/Access.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+
+
+@dataclass
+class Access:
+    """
+    Access
+    """
+    roles: List[str] = None
+    verify_caller: bool = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'Access':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/AccessToken.py

@@ -0,0 +1,75 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+from .AddressClaimSet import AddressClaimSet
+from .Access import Access
+from .Authorization import Authorization
+from .Confirmation import Confirmation
+
+
+@dataclass
+class AccessToken:
+    """
+    AccessToken
+    """
+    jti: str = None
+    exp: int = None
+    nbf: int = None
+    iat: int = None
+    iss: str = None
+    sub: str = None
+    typ: str = None
+    azp: str = None
+    other_claims: dict = None
+    nonce: str = None
+    auth_time: int = None
+    session_state: str = None
+    at_hash: str = None
+    c_hash: str = None
+    name: str = None
+    given_name: str = None
+    family_name: str = None
+    middle_name: str = None
+    nickname: str = None
+    preferred_username: str = None
+    profile: str = None
+    picture: str = None
+    website: str = None
+    email: str = None
+    email_verified: bool = None
+    gender: str = None
+    birthdate: str = None
+    zoneinfo: str = None
+    locale: str = None
+    phone_number: str = None
+    phone_number_verified: bool = None
+    address: AddressClaimSet = None
+    updated_at: int = None
+    claims_locales: str = None
+    acr: str = None
+    s_hash: str = None
+    auth_time: int = None
+    sid: str = None
+    trusted_certs: List[str] = None
+    allowed_origins: List[str] = None
+    realm_access: Access = None
+    resource_access: dict = None
+    authorization: Authorization = None
+    cnf: Confirmation = None
+    scope: str = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'AccessToken':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        if 'address' in snake_data and snake_data['address'] is not None:
+            snake_data['address'] = AddressClaimSet.from_dict(snake_data['address'])
+        if 'realm_access' in snake_data and snake_data['realm_access'] is not None:
+            snake_data['realm_access'] = Access.from_dict(snake_data['realm_access'])
+        if 'authorization' in snake_data and snake_data['authorization'] is not None:
+            snake_data['authorization'] = Authorization.from_dict(snake_data['authorization'])
+        if 'cnf' in snake_data and snake_data['cnf'] is not None:
+            snake_data['cnf'] = Confirmation.from_dict(snake_data['cnf'])
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/AddressClaimSet.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+
+
+@dataclass
+class AddressClaimSet:
+    """
+    AddressClaimSet
+    """
+    formatted: str = None
+    street_address: str = None
+    locality: str = None
+    region: str = None
+    postal_code: str = None
+    country: str = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'AddressClaimSet':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/AdminEventRepresentation.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+from .AuthDetailsRepresentation import AuthDetailsRepresentation
+
+
+@dataclass
+class AdminEventRepresentation:
+    """
+    AdminEventRepresentation
+    """
+    time: int = None
+    realm_id: str = None
+    auth_details: AuthDetailsRepresentation = None
+    operation_type: str = None
+    resource_type: str = None
+    resource_path: str = None
+    representation: str = None
+    error: str = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'AdminEventRepresentation':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        if 'auth_details' in snake_data and snake_data['auth_details'] is not None:
+            snake_data['auth_details'] = AuthDetailsRepresentation.from_dict(snake_data['auth_details'])
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/ApplicationRepresentation.py

@@ -0,0 +1,72 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+from .ProtocolMapperRepresentation import ProtocolMapperRepresentation
+from .ResourceServerRepresentation import ResourceServerRepresentation
+from .ApplicationRepresentationClaims import ApplicationRepresentationClaims
+
+
+@dataclass
+class ApplicationRepresentation:
+    """
+    ApplicationRepresentation
+    """
+    id: str = None
+    client_id: str = None
+    description: str = None
+    root_url: str = None
+    admin_url: str = None
+    base_url: str = None
+    surrogate_auth_required: bool = None
+    enabled: bool = None
+    always_display_in_console: bool = None
+    client_authenticator_type: str = None
+    secret: str = None
+    registration_access_token: str = None
+    default_roles: List[str] = None
+    redirect_uris: List[str] = None
+    web_origins: List[str] = None
+    not_before: int = None
+    bearer_only: bool = None
+    consent_required: bool = None
+    standard_flow_enabled: bool = None
+    implicit_flow_enabled: bool = None
+    direct_access_grants_enabled: bool = None
+    service_accounts_enabled: bool = None
+    oauth2_device_authorization_grant_enabled: bool = None
+    authorization_services_enabled: bool = None
+    direct_grants_only: bool = None
+    public_client: bool = None
+    frontchannel_logout: bool = None
+    protocol: str = None
+    attributes: dict = None
+    authentication_flow_binding_overrides: dict = None
+    full_scope_allowed: bool = None
+    node_re_registration_timeout: int = None
+    registered_nodes: dict = None
+    protocol_mappers: List[ProtocolMapperRepresentation] = None
+    client_template: str = None
+    use_template_config: bool = None
+    use_template_scope: bool = None
+    use_template_mappers: bool = None
+    default_client_scopes: List[str] = None
+    optional_client_scopes: List[str] = None
+    authorization_settings: ResourceServerRepresentation = None
+    access: dict = None
+    origin: str = None
+    name: str = None
+    claims: ApplicationRepresentationClaims = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ApplicationRepresentation':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        if 'protocol_mappers' in snake_data and snake_data['protocol_mappers'] is not None:
+            snake_data['protocol_mappers'] = [ProtocolMapperRepresentation.from_dict(item) for item in snake_data['protocol_mappers']]
+        if 'authorization_settings' in snake_data and snake_data['authorization_settings'] is not None:
+            snake_data['authorization_settings'] = ResourceServerRepresentation.from_dict(snake_data['authorization_settings'])
+        if 'claims' in snake_data and snake_data['claims'] is not None:
+            snake_data['claims'] = ApplicationRepresentationClaims.from_dict(snake_data['claims'])
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/ApplicationRepresentationClaims.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+
+
+@dataclass
+class ApplicationRepresentationClaims:
+    """
+    ApplicationRepresentationClaims
+    """
+    name: bool = None
+    username: bool = None
+    profile: bool = None
+    picture: bool = None
+    website: bool = None
+    email: bool = None
+    gender: bool = None
+    locale: bool = None
+    address: bool = None
+    phone: bool = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ApplicationRepresentationClaims':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/AuthDetailsRepresentation.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+
+
+@dataclass
+class AuthDetailsRepresentation:
+    """
+    AuthDetailsRepresentation
+    """
+    realm_id: str = None
+    client_id: str = None
+    user_id: str = None
+    ip_address: str = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'AuthDetailsRepresentation':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/AuthenticationExecutionExportRepresentation.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+
+
+@dataclass
+class AuthenticationExecutionExportRepresentation:
+    """
+    AuthenticationExecutionExportRepresentation
+    """
+    authenticator_config: str = None
+    authenticator: str = None
+    authenticator_flow: bool = None
+    requirement: str = None
+    priority: int = None
+    autheticator_flow: bool = None
+    flow_alias: str = None
+    user_setup_allowed: bool = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'AuthenticationExecutionExportRepresentation':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/AuthenticationExecutionInfoRepresentation.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+
+
+@dataclass
+class AuthenticationExecutionInfoRepresentation:
+    """
+    AuthenticationExecutionInfoRepresentation
+    """
+    id: str = None
+    requirement: str = None
+    display_name: str = None
+    alias: str = None
+    description: str = None
+    requirement_choices: List[str] = None
+    configurable: bool = None
+    authentication_flow: bool = None
+    provider_id: str = None
+    authentication_config: str = None
+    flow_id: str = None
+    level: int = None
+    index: int = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'AuthenticationExecutionInfoRepresentation':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/AuthenticationExecutionRepresentation.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+
+
+@dataclass
+class AuthenticationExecutionRepresentation:
+    """
+    AuthenticationExecutionRepresentation
+    """
+    authenticator_config: str = None
+    authenticator: str = None
+    authenticator_flow: bool = None
+    requirement: str = None
+    priority: int = None
+    autheticator_flow: bool = None
+    id: str = None
+    flow_id: str = None
+    parent_flow: str = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'AuthenticationExecutionRepresentation':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/AuthenticationFlowRepresentation.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+from .AuthenticationExecutionExportRepresentation import AuthenticationExecutionExportRepresentation
+
+
+@dataclass
+class AuthenticationFlowRepresentation:
+    """
+    AuthenticationFlowRepresentation
+    """
+    id: str = None
+    alias: str = None
+    description: str = None
+    provider_id: str = None
+    top_level: bool = None
+    built_in: bool = None
+    authentication_executions: List[AuthenticationExecutionExportRepresentation] = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'AuthenticationFlowRepresentation':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        if 'authentication_executions' in snake_data and snake_data['authentication_executions'] is not None:
+            snake_data['authentication_executions'] = [AuthenticationExecutionExportRepresentation.from_dict(item) for item in snake_data['authentication_executions']]
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/AuthenticatorConfigInfoRepresentation.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+from .ConfigPropertyRepresentation import ConfigPropertyRepresentation
+
+
+@dataclass
+class AuthenticatorConfigInfoRepresentation:
+    """
+    AuthenticatorConfigInfoRepresentation
+    """
+    name: str = None
+    provider_id: str = None
+    help_text: str = None
+    properties: List[ConfigPropertyRepresentation] = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'AuthenticatorConfigInfoRepresentation':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        if 'properties' in snake_data and snake_data['properties'] is not None:
+            snake_data['properties'] = [ConfigPropertyRepresentation.from_dict(item) for item in snake_data['properties']]
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/AuthenticatorConfigRepresentation.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+
+
+@dataclass
+class AuthenticatorConfigRepresentation:
+    """
+    AuthenticatorConfigRepresentation
+    """
+    id: str = None
+    alias: str = None
+    config: dict = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'AuthenticatorConfigRepresentation':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/Authorization.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+from .Permission import Permission
+
+
+@dataclass
+class Authorization:
+    """
+    Authorization
+    """
+    permissions: List[Permission] = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'Authorization':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        if 'permissions' in snake_data and snake_data['permissions'] is not None:
+            snake_data['permissions'] = [Permission.from_dict(item) for item in snake_data['permissions']]
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/CertificateRepresentation.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+
+
+@dataclass
+class CertificateRepresentation:
+    """
+    CertificateRepresentation
+    """
+    private_key: str = None
+    public_key: str = None
+    certificate: str = None
+    kid: str = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'CertificateRepresentation':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/ClaimRepresentation.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+
+
+@dataclass
+class ClaimRepresentation:
+    """
+    ClaimRepresentation
+    """
+    name: bool = None
+    username: bool = None
+    profile: bool = None
+    picture: bool = None
+    website: bool = None
+    email: bool = None
+    gender: bool = None
+    locale: bool = None
+    address: bool = None
+    phone: bool = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ClaimRepresentation':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/ClientInitialAccessCreatePresentation.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+
+
+@dataclass
+class ClientInitialAccessCreatePresentation:
+    """
+    ClientInitialAccessCreatePresentation
+    """
+    expiration: int = None
+    count: int = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ClientInitialAccessCreatePresentation':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/ClientInitialAccessPresentation.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+
+
+@dataclass
+class ClientInitialAccessPresentation:
+    """
+    ClientInitialAccessPresentation
+    """
+    id: str = None
+    token: str = None
+    timestamp: int = None
+    expiration: int = None
+    count: int = None
+    remaining_count: int = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ClientInitialAccessPresentation':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/ClientMappingsRepresentation.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+from .RoleRepresentation import RoleRepresentation
+
+
+@dataclass
+class ClientMappingsRepresentation:
+    """
+    ClientMappingsRepresentation
+    """
+    id: str = None
+    client: str = None
+    mappings: List[RoleRepresentation] = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ClientMappingsRepresentation':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        if 'mappings' in snake_data and snake_data['mappings'] is not None:
+            snake_data['mappings'] = [RoleRepresentation.from_dict(item) for item in snake_data['mappings']]
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/ClientPoliciesRepresentation.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+from .ClientPolicyRepresentation import ClientPolicyRepresentation
+
+
+@dataclass
+class ClientPoliciesRepresentation:
+    """
+    ClientPoliciesRepresentation
+    """
+    policies: List[ClientPolicyRepresentation] = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ClientPoliciesRepresentation':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        if 'policies' in snake_data and snake_data['policies'] is not None:
+            snake_data['policies'] = [ClientPolicyRepresentation.from_dict(item) for item in snake_data['policies']]
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/ClientPolicyConditionRepresentation.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+
+
+@dataclass
+class ClientPolicyConditionRepresentation:
+    """
+    ClientPolicyConditionRepresentation
+    """
+    condition: str = None
+    configuration: List[dict] = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ClientPolicyConditionRepresentation':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}

checkmarxpythonsdk-1.6.6/CheckmarxPythonSDK/CxOne/KeycloakAPI/dto/ClientPolicyExecutorRepresentation.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass, asdict
+from typing import List
+from inflection import camelize, underscore
+
+
+@dataclass
+class ClientPolicyExecutorRepresentation:
+    """
+    ClientPolicyExecutorRepresentation
+    """
+    executor: str = None
+    configuration: List[dict] = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ClientPolicyExecutorRepresentation':
+        snake_data: dict = {underscore(k): v for k, v in data.items()}
+        return cls(**snake_data)
+
+    def to_dict(self) -> dict:
+        return {camelize(k, False): v for k, v in asdict(self).items() if v is not None}