Used to retrieve the specifications of the schema from the given
        fully_qualified_name of schema.
        :param fully_qualified_name: The fully qualified name of the schema needed.
        :return: Schema dictionary.
974479
def get_schema_spec(self, fully_qualified_name: str) -> Dict[str, Any]:
        

        if fully_qualified_name not in self._spec_cache:
            self.add_errors(SpecNotFoundError(fully_qualified_name, {}))

        return self._spec_cache.get(fully_qualified_name, None)
671401
def qualified_name(self):
        ''''''
        return '{0}.{1}#{2}'.format(self.module.name, self.enum.name, self.name)
404042
def schema():
        """"""
        return Schema({
            'script': And(Or(type(' '), type(u' ')), len),
            Optional('title', default=''): str,
            Optional('model', default={}): {Optional(And(str, len)): object},
            Optional('env', default={}): {Optional(And(str, len)): And(str, len)},
            Optional('item', default=None): object,
            Optional('dry_run', default=False): bool,
            Optional('debug', default=False): bool,
            Optional('strict', default=False): bool,
            Optional('variables', default={}): {
                Optional(And(Or(type(' '), type(u' ')), len, Regex(r'([a-zA-Z][_a-zA-Z]*)'))):
                    Or(type(' '), type(u' '))
            },
            Optional('temporary_scripts_path', default=''): Or(type(''), type(u'')),
            Optional('internal', default=False): bool
        })
445793
def extend_schema_spec(self) -> None:
        
        super().extend_schema_spec()

        identity_field = {
            'Name': '_identity',
            'Type': BtsType.STRING,
            'Value': 'identity',
            ATTRIBUTE_INTERNAL: True
        }

        if self.ATTRIBUTE_FIELDS in self._spec:
            self._spec[self.ATTRIBUTE_FIELDS].insert(0, identity_field)
            self.schema_loader.add_schema_spec(identity_field, self.fully_qualified_name)
1241787
def to_dict(self):
        """"""
        result = {
            'type': get_qualified_name(self),
            'fitted': self.fitted,
            'constant_value': self.constant_value
        }

        if not self.fitted:
            return result

        result.update(self._fit_params())
        return result
1313730
def table(self, name):
        
        qualified_name = self._qualify(name)
        return self.database.table(qualified_name, self.name)
1070634
def get_schema(self, db_name, table_name):
    
    self.send_get_schema(db_name, table_name)
    return self.recv_get_schema()
780412
def schema(self):
        
        if self.status == "DELETING":
            return ""
        parts = ["GLOBAL", self.index_type, "INDEX"]
        parts.append("('%s', %s," % (self.name, self.hash_key.name))
        if self.range_key:
            parts.append("%s," % self.range_key.name)
        if self.includes:
            parts.append("[%s]," % ", ".join(("'%s'" % i for i in self.includes)))

        parts.append(
            "THROUGHPUT (%d, %d))" % (self.read_throughput, self.write_throughput)
        )
        return " ".join(parts)
1036615
def qualified_name(obj):
    """"""
    try:
        module = obj.__module__
        qualname = obj.__qualname__
    except AttributeError:
        type_ = type(obj)
        module = type_.__module__
        qualname = type_.__qualname__

    return qualname if module in ('typing', 'builtins') else '{}.{}'.format(module, qualname)
272902
def dump(schema):
    
    result = {}

    for name, _ in iteritems(schema.getschemas()):

        if hasattr(schema, name):
            val = getattr(schema, name)

            if isinstance(val, DynamicValue):
                val = val()

            if isinstance(val, Schema):
                val = dump(val)

            result[name] = val

    return result
192481
def schema(self):
        
        schema_data = super(GlobalIndex, self).schema(self.hash_key)
        schema_data['ProvisionedThroughput'] = self.throughput.schema()
        return schema_data
787635
def get_qualifier_dict(vocabularies, qualifier_vocab):
    
    # Raise exception if the vocabulary can't be found.
    if vocabularies.get(qualifier_vocab, None) is None:
        raise UNTLFormException(
            'Could not retrieve qualifier vocabulary "%s" for the form.'
            % (qualifier_vocab)
        )
    else:
        # Return the sorted vocabulary.
        return vocabularies.get(qualifier_vocab)
231757
def to_dict(self):
        """"""
        return {'schema': self.schema, 'name': self.name, 'columns': [col.to_dict() for col in self._columns],
                'foreign_keys': self.foreign_keys.to_dict(), 'ref_keys': self.ref_keys.to_dict()}
209166
def _get_data_schema(self):
        

        if not hasattr(self, "_data_schema"):
            response = self.__proxy__.get_data_schema()

            self._data_schema = {k : _turicreate._cython.cy_flexible_type.pytype_from_type_name(v)
                                 for k, v in response["schema"].items()}

        return self._data_schema
1356625
@ManyToOne(targetEntity = org.openprovenance.prov.sql.QualifiedName.class, cascade = {
        CascadeType.ALL
    })
    @JoinColumn(name = "DICTIONARY__DICTIONARYMEMBER_0")
    public org.openprovenance.prov.model.QualifiedName getDictionary() {
        return dictionary;
    }
179740
def _example_from_complex_def(self, prop_spec):
        
        if 'schema' not in prop_spec:
            return [{}]
        elif 'type' not in prop_spec['schema']:
            definition_name = self.get_definition_name_from_ref(prop_spec['schema']['$ref'])
            if self.build_one_definition_example(definition_name):
                return self.definitions_example[definition_name]
        elif prop_spec['schema']['type'] == 'array':  # Array with definition
            # Get value from definition
            if 'items' in prop_spec.keys():
                definition_name = self.get_definition_name_from_ref(prop_spec['items']['$ref'])
            else:
                if '$ref' in prop_spec['schema']['items']:
                    definition_name = self.get_definition_name_from_ref(prop_spec['schema']['items']['$ref'])
                else:
                    definition_name = self.get_definition_name_from_ref(prop_spec['schema']['items']['type'])
                    return [definition_name]
            return [self.definitions_example[definition_name]]
        else:
            return self.get_example_from_prop_spec(prop_spec['schema'])
1279251
def schema_term(self):
        """"""

        if not self.name:
            raise MetapackError("Resource for url '{}' doe not have name".format(self.url))

        t = self.doc.find_first('Root.Table', value=self.get_value('name'))
        frm = 'name'

        if not t:
            t = self.doc.find_first('Root.Table', value=self.get_value('schema'))
            frm = 'schema'

        if not t:
            frm = None

        return t