Python collections_abc.Mapping方法代码示例

# 需要导入模块: from six.moves import collections_abc [as 别名]
# 或者: from six.moves.collections_abc import Mapping [as 别名]
def from_api_repr(cls, api_repr):
        """Return a ``SchemaField`` object deserialized from a dictionary.

        Args:
            api_repr (Mapping[str, str]): The serialized representation
                of the SchemaField, such as what is output by
                :meth:`to_api_repr`.

        Returns:
            google.cloud.biquery.schema.SchemaField: The ``SchemaField`` object.
        """
        # Handle optional properties with default values
        mode = api_repr.get("mode", "NULLABLE")
        description = api_repr.get("description")
        fields = api_repr.get("fields", ())

        return cls(
            field_type=api_repr["type"].upper(),
            fields=[cls.from_api_repr(f) for f in fields],
            mode=mode.upper(),
            description=description,
            name=api_repr["name"],
            policy_tags=PolicyTagList.from_api_repr(api_repr.get("policyTags")),
        ) 

# 需要导入模块: from six.moves import collections_abc [as 别名]
# 或者: from six.moves.collections_abc import Mapping [as 别名]
def _parse_schema_resource(info):
    """Parse a resource fragment into a schema field.

    Args:
        info: (Mapping[str, Dict]): should contain a "fields" key to be parsed

    Returns:
        Optional[Sequence[google.cloud.bigquery.schema.SchemaField`]:
            A list of parsed fields, or ``None`` if no "fields" key found.
    """
    if "fields" not in info:
        return ()

    schema = []
    for r_field in info["fields"]:
        name = r_field["name"]
        field_type = r_field["type"]
        mode = r_field.get("mode", "NULLABLE")
        description = r_field.get("description")
        sub_fields = _parse_schema_resource(r_field)
        policy_tags = PolicyTagList.from_api_repr(r_field.get("policyTags"))
        schema.append(
            SchemaField(name, field_type, mode, description, sub_fields, policy_tags)
        )
    return schema 

# 需要导入模块: from six.moves import collections_abc [as 别名]
# 或者: from six.moves.collections_abc import Mapping [as 别名]
def is_unordered_dict(self, subject):
        if isinstance(subject, collections_abc.Mapping):
            if not hasattr(collections, 'OrderedDict'):
                return True
            return not isinstance(subject, collections.OrderedDict)
        return False 

# 需要导入模块: from six.moves import collections_abc [as 别名]
# 或者: from six.moves.collections_abc import Mapping [as 别名]
def _not_a_dict(self, value):
        return not isinstance(value, collections_abc.Mapping) 

# 需要导入模块: from six.moves import collections_abc [as 别名]
# 或者: from six.moves.collections_abc import Mapping [as 别名]
def revoke(data):
    """Revoke a STIX object.

    Returns:
        A new version of the object with ``revoked`` set to ``True``.
    """
    if not isinstance(data, Mapping):
        raise ValueError(
            "cannot revoke object of this type! Try a dictionary "
            "or instance of an SDO or SRO class.",
        )

    if data.get('revoked'):
        raise RevokeError("revoke")
    return new_version(data, revoked=True) 

# 需要导入模块: from six.moves import collections_abc [as 别名]
# 或者: from six.moves.collections_abc import Mapping [as 别名]
def _to_schema_fields(schema):
    """Coerce `schema` to a list of schema field instances.

    Args:
        schema(Sequence[Union[ \
            :class:`~google.cloud.bigquery.schema.SchemaField`, \
            Mapping[str, Any] \
        ]]):
            Table schema to convert. If some items are passed as mappings,
            their content must be compatible with
            :meth:`~google.cloud.bigquery.schema.SchemaField.from_api_repr`.

    Returns:
        Sequence[:class:`~google.cloud.bigquery.schema.SchemaField`]

    Raises:
        Exception: If ``schema`` is not a sequence, or if any item in the
        sequence is not a :class:`~google.cloud.bigquery.schema.SchemaField`
        instance or a compatible mapping representation of the field.
    """
    for field in schema:
        if not isinstance(field, (SchemaField, collections_abc.Mapping)):
            raise ValueError(
                "Schema items must either be fields or compatible "
                "mapping representations."
            )

    return [
        field if isinstance(field, SchemaField) else SchemaField.from_api_repr(field)
        for field in schema
    ]