Schemas

analyzer = Analyzer(
    tokenizer=Tokenizer(name="standard"),
    filters=[
        Filter(name="lowercase"),
        Filter(name="stop", ignore_case=True, words="stopwords.txt")
    ]
)

from taiyo.schema.enums import SolrCharFilterFactory

# Using enum
char_filter = CharFilter(
    solr_class=SolrCharFilterFactory.PATTERN_REPLACE,
    pattern="([a-zA-Z])\\1+",
    replacement="$1$1"
)

# Or using string
char_filter = CharFilter(
    name="patternReplace",
    pattern="([a-zA-Z])\\1+",
    replacement="$1$1"
)

from taiyo.schema import CopyField

# Copy single field to catch-all
title_copy = CopyField(source="title", dest="text")
content_copy = CopyField(source="content", dest="text")

# Copy all text fields with wildcard
all_text_copy = CopyField(source="*_txt", dest="text")

# Copy with character limit for summaries
summary_copy = CopyField(
    source="content",
    dest="content_summary",
    maxChars=500
)

# Copy for different analysis
# (e.g., stemmed text to unstemmed for exact phrase matching)
exact_copy = CopyField(source="description", dest="description_exact")

# Copy multiple dynamic fields
multi_lang_copy = CopyField(source="title_*", dest="title_all")

from taiyo.schema.enums import SolrFilterFactory

# Using enum
filter = Filter(solr_class=SolrFilterFactory.LOWER_CASE)

# Using name
filter = Filter(name="lowercase")

# With parameters using enum
filter = Filter(
    solr_class=SolrFilterFactory.STOP,
    ignore_case=True,
    words="stopwords.txt"
)

# With parameters using name
filter = Filter(
    name="stop",
    ignore_case=True,
    words="stopwords.txt"
)

from taiyo.schema import (
    Schema, SolrField, SolrDynamicField,
    SolrFieldType, SolrFieldClass, CopyField
)
from taiyo.schema.field_type import Analyzer, Tokenizer, Filter

# Define field types
text_type = SolrFieldType(
    name="text_general",
    solr_class=SolrFieldClass.TEXT,
    position_increment_gap=100,
    analyzer=Analyzer(
        tokenizer=Tokenizer(name="standard"),
        filters=[
            Filter(name="lowercase"),
            Filter(name="stop", words="stopwords.txt")
        ]
    )
)

# Define fields
id_field = SolrField(
    name="id",
    type="string",
    indexed=True,
    stored=True,
    required=True
)

title_field = SolrField(
    name="title",
    type="text_general",
    indexed=True,
    stored=True
)

# Define dynamic fields
text_dynamic = SolrDynamicField(
    name="*_txt",
    type="text_general",
    indexed=True,
    stored=True
)

# Define copy fields
title_copy = CopyField(source="title", dest="text")

# Build complete schema
schema = Schema(
    name="my_collection",
    version=1.6,
    uniqueKey="id",
    fields=[id_field, title_field],
    dynamicFields=[text_dynamic],
    fieldTypes=[text_type],
    copyFields=[title_copy]
)

# Serialize to XML for schema.xml
xml_output = schema.build(format="xml")
with open("schema.xml", "w") as f:
    f.write(xml_output)

# Serialize to JSON for Schema API
json_output = schema.build(format="json")

# Use builder pattern
schema = (
    Schema(name="my_schema", version=1.6, uniqueKey="id")
    .add_field_type(text_type)
    .add_field(id_field)
    .add_field(title_field)
    .add_dynamic_field(text_dynamic)
    .add_copy_field(title_copy)
)

from taiyo.schema.enums import SolrCharFilterFactory

analyzer_config = {
    "charFilters": [
        {"class": SolrCharFilterFactory.HTML_STRIP},
        {"class": SolrCharFilterFactory.MAPPING, "mapping": "mapping-FoldToASCII.txt"}
    ],
    "tokenizer": {"class": "solr.StandardTokenizerFactory"}
}

from taiyo.schema import SolrDynamicField

# Text fields with suffix pattern
text_dynamic = SolrDynamicField(
    name="*_txt",
    type="text_general",
    indexed=True,
    stored=True,
    multi_valued=True
)

# String fields with suffix pattern
string_dynamic = SolrDynamicField(
    name="*_s",
    type="string",
    indexed=True,
    stored=True,
    doc_values=True
)

# Integer fields with suffix pattern
int_dynamic = SolrDynamicField(
    name="*_i",
    type="pint",
    indexed=True,
    stored=True,
    doc_values=True
)

# Date fields with suffix pattern
date_dynamic = SolrDynamicField(
    name="*_dt",
    type="pdate",
    indexed=True,
    stored=True,
    doc_values=True
)

# Attribute fields with prefix pattern
attr_dynamic = SolrDynamicField(
    name="attr_*",
    type="text_general",
    indexed=True,
    stored=True
)

# Ignored fields (no indexing or storage)
ignored_dynamic = SolrDynamicField(
    name="ignored_*",
    type="string",
    indexed=False,
    stored=False
)

from taiyo.schema import SolrField

# Unique ID field
id_field = SolrField(
    name="id",
    type="string",
    indexed=True,
    stored=True,
    required=True
)

# Text field for full-text search
title_field = SolrField(
    name="title",
    type="text_general",
    indexed=True,
    stored=True
)

# Multi-valued field
tags_field = SolrField(
    name="tags",
    type="string",
    indexed=True,
    stored=True,
    multi_valued=True
)

# Field with docValues for faceting
category_field = SolrField(
    name="category",
    type="string",
    indexed=True,
    stored=True,
    doc_values=True
)

# Numeric field with default value
price_field = SolrField(
    name="price",
    type="pdouble",
    indexed=True,
    stored=True,
    default=0.0
)

# Version field (internal)
version_field = SolrField(
    name="_version_",
    type="plong",
    indexed=False,
    stored=False
)

from taiyo.schema import SolrFieldType, SolrFieldClass

# Text field type
text_type = SolrFieldType(
    name="text_en",
    solr_class=SolrFieldClass.TEXT,
    analyzer=...
)

# Numeric field type
int_type = SolrFieldType(
    name="pint",
    solr_class=SolrFieldClass.INT_POINT
)

# Vector field type
vector_type = SolrFieldType(
    name="vector",
    solr_class=SolrFieldClass.DENSE_VECTOR,
    vectorDimension=768
)

from taiyo.schema import SolrFieldType, Analyzer, Tokenizer, Filter
from taiyo.schema.enums import (
    SolrFieldClass,
    SolrTokenizerFactory,
    SolrFilterFactory
)

# Using enums (recommended)
field_type = SolrFieldType(
    name="text_general",
    solr_class=SolrFieldClass.TEXT,
    position_increment_gap=100,
    analyzer=Analyzer(
        tokenizer=Tokenizer(solr_class=SolrTokenizerFactory.STANDARD),
        filters=[
            Filter(solr_class=SolrFilterFactory.LOWER_CASE),
            Filter(solr_class=SolrFilterFactory.STOP, ignore_case=True, words="stopwords.txt")
        ]
    )
)

# Or using strings (also supported)
field_type = SolrFieldType(
    name="text_general",
    solr_class="solr.TextField",
    position_increment_gap=100,
    analyzer=Analyzer(
        tokenizer=Tokenizer(name="standard"),
        filters=[
            Filter(name="lowercase"),
            Filter(name="stop", ignore_case=True, words="stopwords.txt")
        ]
    )
)

from taiyo.schema.enums import SolrFilterFactory

analyzer_config = {
    "tokenizer": {"class": "solr.StandardTokenizerFactory"},
    "filters": [
        {"class": SolrFilterFactory.LOWER_CASE},
        {"class": SolrFilterFactory.STOP, "words": "stopwords.txt"},
        {"class": SolrFilterFactory.PORTER_STEM}
    ]
}

from taiyo.schema import SolrFieldType, Tokenizer
from taiyo.schema.enums import SolrTokenizerFactory

field_type = SolrFieldType(
    name="text_standard",
    solr_class="solr.TextField",
    analyzer=Analyzer(
        tokenizer=Tokenizer(solr_tokenizer_class=SolrTokenizerFactory.STANDARD)
    )
)

from taiyo.schema.enums import SolrTokenizerFactory

# Using enum
tokenizer = Tokenizer(solr_class=SolrTokenizerFactory.STANDARD)

# Or using name
tokenizer = Tokenizer(name="standard")

# Or using string class
tokenizer = Tokenizer(solr_class="solr.StandardTokenizerFactory")