Python VocabString.from_dict方法代码示例

# 需要导入模块: from stix.common import VocabString [as 别名]
# 或者: from stix.common.VocabString import from_dict [as 别名]
    def from_dict(cls, dict_repr, return_obj=None):
        if not dict_repr:
            return None
        if not return_obj:
            return_obj = cls()

        super(CourseOfAction, cls).from_dict(dict_repr, return_obj=return_obj)

        get = dict_repr.get
        return_obj.stage = VocabString.from_dict(get('stage'))
        return_obj.type_ = VocabString.from_dict(get('type'))
        return_obj.objective = Objective.from_dict(get('objective'))
        return_obj.parameter_observables = \
            Observables.from_dict(get('parameter_observables'))
        return_obj.impact = Statement.from_dict(get('impact'))
        return_obj.cost = Statement.from_dict(get('cost'))
        return_obj.efficacy = Statement.from_dict(get('efficacy'))
        return_obj.related_coas = \
            RelatedCOAs.from_dict(get('related_coas'))
        return_obj.related_packages = \
            related.RelatedPackageRefs.from_dict(get('related_packages'))
        return_obj.structured_coa = \
            _BaseStructuredCOA.from_dict(get('structured_coa'))

        return return_obj

# 需要导入模块: from stix.common import VocabString [as 别名]
# 或者: from stix.common.VocabString import from_dict [as 别名]
    def from_dict(cls, dict_repr, return_obj=None):
        if not dict_repr:
            return None
        if not return_obj:
            return_obj = cls()

        return_obj.id_ = dict_repr.get('id')
        return_obj.idref = dict_repr.get('idref')
        return_obj.timestamp = dict_repr.get('timestamp')
        return_obj.version = dict_repr.get('version')
        return_obj.title = dict_repr.get('title')
        return_obj.stage = VocabString.from_dict(dict_repr.get('stage'))
        return_obj.type_ = VocabString.from_dict(dict_repr.get('type'))
        return_obj.description = StructuredText.from_dict(dict_repr.get('description'))
        return_obj.short_description = StructuredText.from_dict(dict_repr.get('short_description'))
        return_obj.objective = Objective.from_dict(dict_repr.get('objective'))
        return_obj.parameter_observables = \
                Observables.from_dict(dict_repr.get('parameter_observables'))
        return_obj.impact = Statement.from_dict(dict_repr.get('impact'))
        return_obj.cost = Statement.from_dict(dict_repr.get('cost'))
        return_obj.efficacy = Statement.from_dict(dict_repr.get('efficacy'))
        return_obj.information_source = InformationSource.from_dict(dict_repr.get('information_source'))
        return_obj.handling = Marking.from_dict(dict_repr.get('handling'))
        return_obj.related_coas = \
                RelatedCOAs.from_dict(dict_repr.get('related_coas'))
        return_obj.related_packages = \
                RelatedPackageRefs.from_dict(dict_repr.get('related_packages'))

        return return_obj

# 需要导入模块: from stix.common import VocabString [as 别名]
# 或者: from stix.common.VocabString import from_dict [as 别名]
    def from_dict(cls, dict_repr, return_obj=None):
        if not dict_repr:
            return None

        if not return_obj:
            return_obj = cls()

        super(Incident, cls).from_dict(dict_repr, return_obj=return_obj)

        get = dict_repr.get
        return_obj.time = Time.from_dict(get('time'))
        return_obj.victims = _Victims.from_dict(get('victims'))
        return_obj.categories = IncidentCategories.from_dict(get('categories'))
        return_obj.attributed_threat_actors = AttributedThreatActors.from_dict(get('attributed_threat_actors'))
        return_obj.related_indicators = RelatedIndicators.from_dict(get('related_indicators'))
        return_obj.related_observables = RelatedObservables.from_dict(get('related_observables'))
        return_obj.related_incidents = RelatedIncidents.from_dict(get('related_incidents'))
        return_obj.intended_effects = _IntendedEffects.from_list(get('intended_effects'))
        return_obj.leveraged_ttps = LeveragedTTPs.from_dict(get('leveraged_ttps'))
        return_obj.affected_assets = AffectedAssets.from_dict(get('affected_assets'))
        return_obj.discovery_methods = DiscoveryMethods.from_dict(get('discovery_methods'))
        return_obj.reporter = InformationSource.from_dict(get('reporter'))
        return_obj.responders = _InformationSources.from_dict(get('responders'))
        return_obj.coordinators = _InformationSources.from_dict(get('coordinators'))
        return_obj.external_ids = _ExternalIDs.from_dict(get('external_ids'))
        return_obj.impact_assessment = ImpactAssessment.from_dict(get('impact_assessment'))
        return_obj.security_compromise = VocabString.from_dict(get('security_compromise'))
        return_obj.confidence = Confidence.from_dict(get('confidence'))
        return_obj.coa_taken = _COAsTaken.from_dict(get('coa_taken'))
        return_obj.coa_requested = _COAsRequested.from_dict(get('coa_requested'))
        return_obj.status = VocabString.from_dict(get('status'))
        return_obj.history = History.from_dict(get('history'))
        return_obj.related_packages = RelatedPackageRefs.from_dict(get('related_packages'))

        return return_obj

# 需要导入模块: from stix.common import VocabString [as 别名]
# 或者: from stix.common.VocabString import from_dict [as 别名]
    def from_dict(cls, dict_, return_obj=None):
        if not dict_:
            return None

        if not return_obj:
            return_obj = cls()

        return_obj.asset_losses = VocabString.from_dict(dict_.get('asset_losses'))
        return_obj.business_mission_disruption = VocabString.from_dict(dict_.get('business_mission_disruption'))
        return_obj.response_and_recovery_costs = VocabString.from_dict(dict_.get('response_and_recovery_costs'))

        return return_obj

# 需要导入模块: from stix.common import VocabString [as 别名]
# 或者: from stix.common.VocabString import from_dict [as 别名]
    def from_dict(cls, dict_repr, return_obj=None):
        if not dict_repr:
            return None
        if not return_obj:
            return_obj = cls()

        return_obj.identity = Identity.from_dict(dict_repr.get('identity'))
        return_obj.targeted_systems = [VocabString.from_dict(x) for x in dict_repr.get('targeted_systems', [])]
        return_obj.targeted_information = [VocabString.from_dict(x) for x in dict_repr.get('targeted_information', [])]
        return_obj.targeted_technical_details = Observables.from_dict(dict_repr.get('targeted_technical_details'))

        return return_obj

# 需要导入模块: from stix.common import VocabString [as 别名]
# 或者: from stix.common.VocabString import from_dict [as 别名]
 def from_dict(cls, d, return_obj=None):
     if not d:
         return None
     if not return_obj:
         return_obj = cls()
         
     return_obj.property_ = VocabString.from_dict(d.get('property'))
     return_obj.description_of_effect = StructuredText.from_dict(d.get('description_of_effect'))
     return_obj.type_of_availability_loss = VocabString.from_dict(d.get('type_of_availability_loss'))
     return_obj.duration_of_availability_loss = VocabString.from_dict(d.get('duration_of_availability_loss'))
     return_obj.non_public_data_compromised = NonPublicDataCompromised.from_dict(d.get('non_public_data_compromised'))
     
     return return_obj

# 需要导入模块: from stix.common import VocabString [as 别名]
# 或者: from stix.common.VocabString import from_dict [as 别名]
    def from_dict(cls, dict_, return_obj=None):
        if not dict_:
            return None

        if not return_obj:
            return_obj = cls()

        return_obj.loss_of_competitive_advantage = VocabString.from_dict(dict_.get('loss_of_competitive_advantage'))
        return_obj.brand_and_market_damage = VocabString.from_dict(dict_.get('brand_and_market_damage'))
        return_obj.increased_operating_costs = VocabString.from_dict(dict_.get('increased_operating_costs'))
        return_obj.legal_and_regulatory_costs = VocabString.from_dict(dict_.get('legal_and_regulatory_costs'))

        return return_obj

# 需要导入模块: from stix.common import VocabString [as 别名]
# 或者: from stix.common.VocabString import from_dict [as 别名]
    def from_dict(cls, dict_repr, return_obj=None):
        if not dict_repr:
            return None

        if not return_obj:
            return_obj = cls()

        super(Campaign, cls).from_dict(dict_repr, return_obj=return_obj)

        get = dict_repr.get  # PEP 8 line lengths
        return_obj.names = Names.from_dict(get('names'))
        return_obj.intended_effects = \
            _IntendedEffects.from_dict(get('intended_effects'))
        return_obj.status = VocabString.from_dict(get('status'))
        return_obj.related_ttps = \
            RelatedTTPs.from_dict(get('related_ttps'))
        return_obj.related_incidents = \
            RelatedIncidents.from_dict(get('related_incidents'))
        return_obj.related_indicators = \
            RelatedIndicators.from_dict(get('related_indicators'))
        return_obj.attribution = _AttributionList.from_list(get('attribution'))
        return_obj.associated_campaigns = \
            AssociatedCampaigns.from_dict(get('associated_campaigns'))
        return_obj.confidence = \
            Confidence.from_dict(get('confidence'))
        return_obj.activity = _Activities.from_dict(get('activity'))
        return_obj.related_packages = \
            RelatedPackageRefs.from_dict(get('related_packages'))

        return return_obj

# 需要导入模块: from stix.common import VocabString [as 别名]
# 或者: from stix.common.VocabString import from_dict [as 别名]
    def from_dict(cls, d, return_obj=None):
        if not d:
            return None
        if not return_obj:
            return_obj = cls()

        get = d.get
        return_obj.type_ = AssetType.from_dict(get('type'))
        return_obj.description = StructuredText.from_dict(get('description'))
        return_obj.business_function_or_role = StructuredText.from_dict(get('business_function_or_role'))
        return_obj.ownership_class = VocabString.from_dict(get('ownership_class'))
        return_obj.management_class = VocabString.from_dict(get('management_class'))
        return_obj.location_class = VocabString.from_dict(get('location_class'))
        # return_obj.location = Location.from_dict(get('location'))
        return_obj.nature_of_security_effect = NatureOfSecurityEffect.from_dict(get('nature_of_security_effect'))
        return_obj.structured_description = Observables.from_dict(get('structured_description'))
        return return_obj

# 需要导入模块: from stix.common import VocabString [as 别名]
# 或者: from stix.common.VocabString import from_dict [as 别名]
    def from_dict(cls, dict_repr, return_obj=None):
        if not dict_repr:
            return None
        
        if not return_obj:
            xsi_type = dict_repr.get('xsi:type')
            if xsi_type:
                klass = MalwareInstance.lookup_class(dict_repr.get('xsi:type'))
                return_obj = klass.from_dict(dict_repr)
            else:
                return_obj = MalwareInstance.from_dict(dict_repr, cls())
        else:
            return_obj.id_ = dict_repr.get('id')
            return_obj.title = dict_repr.get('title')
            return_obj.description = StructuredText.from_dict(dict_repr.get('description'))
            return_obj.short_description = StructuredText.from_dict(dict_repr.get('short_description'))
            return_obj.names = [VocabString.from_dict(x) for x in dict_repr.get('names', [])]
            return_obj.types = [VocabString.from_dict(x) for x in dict_repr.get('types', [])]

        return return_obj

# 需要导入模块: from stix.common import VocabString [as 别名]
# 或者: from stix.common.VocabString import from_dict [as 别名]
 def from_dict(cls, d, return_obj=None):
     if not d:
         return None
     if not return_obj:
         return_obj = cls()
         
     super(GenericTestMechanism, cls).from_dict(d, return_obj)
     return_obj.reference_location = d.get('reference_location')
     return_obj.description = StructuredText.from_dict(d.get('description'))
     return_obj.type_ = VocabString.from_dict(d.get('type'))
     return_obj.specification = EncodedCDATA.from_dict(d.get('specification'))
     
     return return_obj

# 需要导入模块: from stix.common import VocabString [as 别名]
# 或者: from stix.common.VocabString import from_dict [as 别名]
    def from_dict(cls, dict_repr, return_obj=None):
        if not dict_repr:
            return None
        if not return_obj:
            return_obj = cls()

        return_obj.id_ = dict_repr.get('id')
        return_obj.title = dict_repr.get('title')
        return_obj.description = StructuredText.from_dict(dict_repr.get('description'))
        return_obj.short_description = StructuredText.from_dict(dict_repr.get('short_description'))
        return_obj.types = [VocabString.from_dict(x) for x in dict_repr.get('types', [])]
        return_obj.observable_characterization = Observables.from_dict(dict_repr.get('observable_characterization'))

        return return_obj

# 需要导入模块: from stix.common import VocabString [as 别名]
# 或者: from stix.common.VocabString import from_dict [as 别名]
    def from_dict(cls, dict_, return_obj=None):
        if not dict_:
            return None

        if not return_obj:
            return_obj = cls()

        return_obj.direct_impact_summary = DirectImpactSummary.from_dict(dict_.get('direct_impact_summary'))
        return_obj.indirect_impact_summary = IndirectImpactSummary.from_dict(dict_.get('indirect_impact_summary'))
        return_obj.total_loss_estimation = TotalLossEstimation.from_dict(dict_.get('total_loss_estimation'))
        return_obj.impact_qualification = ImpactQualification.from_dict(dict_.get('impact_qualification'))
        return_obj.effects = [VocabString.from_dict(x) for x in dict_.get('effects', [])]

        return return_obj

# 需要导入模块: from stix.common import VocabString [as 别名]
# 或者: from stix.common.VocabString import from_dict [as 别名]
    def from_dict(cls, dict_repr, return_obj=None):
        if not dict_repr:
            return None

        if not return_obj:
            return_obj = cls()

        return_obj.title = dict_repr.get('title')
        return_obj.package_intents = [VocabString.from_dict(x) for x in dict_repr.get('package_intents', [])]
        return_obj.description = StructuredText.from_dict(dict_repr.get('description'))
        return_obj.handling = Marking.from_dict(dict_repr.get('handling'))
        return_obj.information_source = InformationSource.from_dict(dict_repr.get('information_source'))
        return_obj.profiles = dict_repr.get('profiles')

        return return_obj

# 需要导入模块: from stix.common import VocabString [as 别名]
# 或者: from stix.common.VocabString import from_dict [as 别名]
    def from_dict(cls, dict_repr, return_obj=None):
        if not dict_repr:
            return None

        if not return_obj:
            return_obj = cls()
        
        get = dict_repr.get
        return_obj.direct_impact_summary = DirectImpactSummary.from_dict(get('direct_impact_summary'))
        return_obj.indirect_impact_summary = IndirectImpactSummary.from_dict(get('indirect_impact_summary'))
        return_obj.total_loss_estimation = TotalLossEstimation.from_dict(get('total_loss_estimation'))
        return_obj.impact_qualification = VocabString.from_dict(get('impact_qualification'))
        return_obj.effects = Effects.from_dict(get('effects'))

        return return_obj