pydoptic-elastic 0.0.1.post1.dev2__tar.gz

pydoptic_elastic-0.0.1.post1.dev2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 John Hungerford
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pydoptic_elastic-0.0.1.post1.dev2/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: pydoptic-elastic
+Version: 0.0.1.post1.dev2
+Summary: An Elasticsearch integration built on pydoptic
+Author: John Hungerford
+License-Expression: MIT
+Project-URL: Source, https://github.com/johnhungerford/pydoptic
+Requires-Python: <3.14,>=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydoptic
+Requires-Dist: elasticsearch==8.14.0
+Provides-Extra: test
+Requires-Dist: pytest~=8.4.2; extra == "test"
+Provides-Extra: types
+Requires-Dist: mypy~=1.18.2; extra == "types"
+Dynamic: license-file
+
+# pydoptic-elastic
+
+An Elasticsearch integration built on [pydoptic](https://pypi.org/project/pydoptic/).
+
+`ElasticModel` captures index and field-mapping metadata directly on the model's `Prop`s, and `Query`
+lets you build Elasticsearch queries by referencing those `Prop`s directly -- no field or index names
+passed as bare strings.
+
+## Installation
+
+```bash
+pip install pydoptic-elastic
+```
+
+Includes the `elasticsearch` client as a regular dependency, so no extras are needed.
+
+## Quickstart
+
+```python3
+from pydoptic import Prop
+from pydoptic_elastic import ElasticModel, ElasticService, Query, elastic_prop, ESMapping
+from elasticsearch import Elasticsearch
+
+class Person(ElasticModel):
+    name: Prop['Person', str] = elastic_prop(mapping=ESMapping.keyword)
+    age: Prop['Person', int]
+
+service = ElasticService(Elasticsearch('http://localhost:9200'))
+service.create_index(Person)
+
+service.index(Person(name='John', age=42))
+
+query = Query.match(Person.name, 'John')
+for person in service.search(query):
+    print(Person.name.get_val(person))
+    # John
+
+# Retrieve only specific fields, as a PartialModel:
+for person in service.search_partial(query, source=[Person.name]):
+    print(Person.name.get_val_unsafe(person))
+    # John
+```
+
+See the [pydoptic README](https://github.com/johnhungerford/pydoptic/tree/main/packages/pydoptic) for
+the underlying `Prop`/`Select` model this is built on.

pydoptic_elastic-0.0.1.post1.dev2/README.md

@@ -0,0 +1,45 @@
+# pydoptic-elastic
+
+An Elasticsearch integration built on [pydoptic](https://pypi.org/project/pydoptic/).
+
+`ElasticModel` captures index and field-mapping metadata directly on the model's `Prop`s, and `Query`
+lets you build Elasticsearch queries by referencing those `Prop`s directly -- no field or index names
+passed as bare strings.
+
+## Installation
+
+```bash
+pip install pydoptic-elastic
+```
+
+Includes the `elasticsearch` client as a regular dependency, so no extras are needed.
+
+## Quickstart
+
+```python3
+from pydoptic import Prop
+from pydoptic_elastic import ElasticModel, ElasticService, Query, elastic_prop, ESMapping
+from elasticsearch import Elasticsearch
+
+class Person(ElasticModel):
+    name: Prop['Person', str] = elastic_prop(mapping=ESMapping.keyword)
+    age: Prop['Person', int]
+
+service = ElasticService(Elasticsearch('http://localhost:9200'))
+service.create_index(Person)
+
+service.index(Person(name='John', age=42))
+
+query = Query.match(Person.name, 'John')
+for person in service.search(query):
+    print(Person.name.get_val(person))
+    # John
+
+# Retrieve only specific fields, as a PartialModel:
+for person in service.search_partial(query, source=[Person.name]):
+    print(Person.name.get_val_unsafe(person))
+    # John
+```
+
+See the [pydoptic README](https://github.com/johnhungerford/pydoptic/tree/main/packages/pydoptic) for
+the underlying `Prop`/`Select` model this is built on.

pydoptic_elastic-0.0.1.post1.dev2/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=64", "setuptools-scm>=8"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pydoptic-elastic"
+dynamic = ["version"]
+authors = [{ name = "John Hungerford" }]
+urls = { Source = "https://github.com/johnhungerford/pydoptic" }
+description = "An Elasticsearch integration built on pydoptic"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.8,<3.14"
+dependencies = [
+    "pydoptic",
+    "elasticsearch==8.14.0",
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest~=8.4.2",
+]
+types = [
+    "mypy~=1.18.2",
+]
+
+[tool.setuptools_scm]
+# See packages/pydoptic/pyproject.toml -- same repo-wide lockstep version, same reasoning.
+root = "../.."
+version_scheme = "no-guess-dev"
+local_scheme = "no-local-version"
+
+[tool.pytest.ini_options]
+markers = [
+    "integration: requires a live Elasticsearch instance started via docker-compose.yml; excluded by default, opt in with `-m integration`",
+]
+addopts = "-m 'not integration'"

pydoptic_elastic-0.0.1.post1.dev2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pydoptic_elastic-0.0.1.post1.dev2/src/pydoptic_elastic/__init__.py

@@ -0,0 +1,9 @@
+from pydoptic_elastic.elastic_model import ESFieldData, ESMapping, ElasticModel, elastic_prop
+from pydoptic_elastic.elastic_service import ElasticService
+from pydoptic_elastic.elastic_query import Query
+
+__all__ = [
+    'ESFieldData', 'ESMapping', 'ElasticModel', 'elastic_prop',
+    'ElasticService',
+    'Query',
+]

pydoptic_elastic-0.0.1.post1.dev2/src/pydoptic_elastic/elastic_model.py

@@ -0,0 +1,88 @@
+from datetime import date, datetime
+from enum import Enum
+from typing import Any, ClassVar, Dict, Optional, TypeVar, TypedDict, Unpack, cast
+
+from pydoptic import BaseModel, select
+from pydoptic.selector import Discrim, PropSelect, LinkedSelect, Select
+
+class ESFieldData(TypedDict):
+    mapping: Optional['ESMapping']
+
+TERM_SUFFIX = 'term'
+
+class ESMapping(Enum):
+    text_keyword = 'text_keyword'
+    text = 'text'
+    keyword = 'keyword'
+    long = 'long'
+    double = 'double'
+    boolean = 'boolean'
+    date = 'date'
+
+    @classmethod
+    def from_select(self, prop: Select[Any, Any]) -> 'ESMapping':
+        match prop:
+            case PropSelect():
+                data = cast(ESFieldData, prop.data)
+                mapping = data.get('mapping')
+                if mapping is not None:
+                    return mapping
+                return _mappings_lookup.get(prop.target) or ESMapping.text_keyword
+            case LinkedSelect(select_2=prop):
+                return self.from_select(prop)
+            case _:
+                raise ValueError()
+
+    def to_dict(self) -> Dict[str, Any]:
+        match self:
+            case ESMapping.text_keyword:
+                return {'type': 'text', 'fields': {TERM_SUFFIX: {'type': 'keyword'}}}
+            case ESMapping.text:
+                return {'type': 'text'}
+            case ESMapping.keyword:
+                return {'type': 'keyword'}
+            case ESMapping.long:
+                return {'type': 'long'}
+            case ESMapping.double:
+                return {'type': 'double'}
+            case ESMapping.boolean:
+                return {'type': 'boolean'}
+            case ESMapping.date:
+                return {'type': 'date'}
+
+_mappings_lookup = {
+    str: ESMapping.text_keyword,
+    int: ESMapping.long,
+    float: ESMapping.double,
+    bool: ESMapping.boolean,
+    date: ESMapping.date,
+    datetime: ESMapping.date,
+}
+
+class ElasticModel(BaseModel):
+    index_name: ClassVar[str]
+
+    @classmethod
+    def _get_index_name(cls) -> str:
+        try:
+            return cls.index_name
+        except AttributeError:
+            return cls.__name__.lower()
+    
+    @classmethod
+    def _get_mappings(cls) -> Dict[str, Any]:
+        mappings: Dict[str, Any] = {}
+        for prop in cls.properties().values():
+            if isinstance(prop, PropSelect):
+                if issubclass(prop.target, ElasticModel):
+                    mappings[prop.label] = {'type': 'object', 'properties': prop.target._get_mappings()}
+                else:
+                    mappings[prop.label] = ESMapping.from_select(prop).to_dict()
+            elif isinstance(prop, Discrim):
+                mappings[prop.property.label] = ESMapping.keyword
+        return mappings
+
+M = TypeVar('M', bound=ElasticModel)
+
+def elastic_prop(name: str | None = None, **field_data: Unpack[ESFieldData]) -> Any:
+    return select(name, **field_data)

pydoptic_elastic-0.0.1.post1.dev2/src/pydoptic_elastic/elastic_query.py

@@ -0,0 +1,154 @@
+from typing import TypeVar, Generic, Dict, Any, Type, List
+
+from pydoptic import Select
+from pydoptic_elastic.elastic_model import M, TERM_SUFFIX, ESMapping
+
+A = TypeVar('A')
+
+class Query(Generic[M]):
+    def to_dict(self) -> Dict[str, Any]:
+        raise NotImplementedError()
+
+    @property
+    def model(self) -> Type[M]:
+        raise NotImplementedError()
+
+    @classmethod
+    def match(cls, select: Select[M, A], value: A, **kwargs) -> 'MatchQuery[M]':
+        return MatchQuery(select, value)
+
+    @classmethod
+    def bool(
+        cls,
+        should: List['Query[M]'] | None = None,
+        must: List['Query[M]'] | None = None,
+        filter: List['Query[M]'] | None = None,
+        must_not: List['Query[M]'] | None = None,
+        minimum_should_match: int | None = None,
+    ) -> 'BoolQuery[M]':
+        return BoolQuery(should=should or [], must=must or [], filter=filter or [], must_not=must_not or [], minimum_should_match=minimum_should_match)
+
+    @classmethod
+    def term(cls, select: Select[M, str], value: str, **kwargs) -> 'TermQuery[M]':
+        return TermQuery(select, value, **kwargs)
+
+    @classmethod
+    def exists(cls, select: Select[M, A]) -> 'ExistsQuery[M]':
+        return ExistsQuery(select)
+
+    @classmethod
+    def manual(cls, model: Type[M], query: Dict[str, Any]) -> 'ManualQuery[M]':
+        return ManualQuery(model, query)
+
+class ManualQuery(Generic[M]):
+    def __init__(self, mdl: Type[M], query: Dict[str, Any]):
+        self.mdl = mdl
+        self.query = query
+
+    def to_dict(self) -> Dict[str, Any]:
+        return self.query
+
+    def model(self) -> Type[M]:
+        return self.mdl
+
+class ExistsQuery(Query[M]):
+    def __init__(self, select: Select[M, A]) -> None:
+        self.select = select
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {'exists': {'field': self.select.path}}
+
+    @property
+    def model(self) -> Type[M]:
+        return self.select.origin
+
+class TermQuery(Query[M]):
+    def __init__(self, select: Select[M, str], value: str, **options) -> None:
+        self.select = select
+        self.value = value
+        self.options = options
+
+    def to_dict(self) -> Dict[str, Any]:
+        match ESMapping.from_select(self.select):
+            case ESMapping.keyword:
+                path = self.select.path
+            case ESMapping.text_keyword:
+                path = self.select.path + '.' + TERM_SUFFIX
+            case other:
+                raise ValueError(f'Term query unsupported on {self.select.path} (mapping type: {other.value})')
+        return {'term': {path: {'value': self.value, **self.options}}}
+
+    @property
+    def model(self) -> Type[M]:
+        return self.select.origin
+
+class BoolQuery(Query[M]):
+    def __init__(self, should: List[Query[M]], must: List[Query[M]], filter: List[Query[M]], must_not: List[Query[M]], minimum_should_match: int | None = None) -> None:
+        self.should = should
+        self.must = must
+        self.filter = filter
+        self.must_not = must_not
+        self.mdl: Type[M] | None = None
+        self.minimum_should_match = minimum_should_match
+
+    def to_dict(self) -> Dict[str, Any]:
+        bool_obj: Dict[str, Any] = {}
+        if len(self.should) > 0:
+            bool_obj['should'] = self.should
+        if len(self.must) > 0:
+            bool_obj['must'] = self.must
+        if len(self.filter) > 0:
+            bool_obj['filter'] = self.filter
+        if len(self.must_not) > 0:
+            bool_obj['must_not'] = self.must_not
+        if self.minimum_should_match is not None:
+            bool_obj['minimum_should_match'] = self.minimum_should_match
+        return {'bool': bool_obj}
+
+    @property
+    def model(self) -> Type[M]:
+        if self.mdl is not None:
+            return self.mdl
+        else:
+            for batch in [self.should, self.must, self.must_not, self.filter]:
+                for query in batch:
+                    self.mdl = query.model
+                    return self.mdl
+            raise ValueError(f'Bool query contains no queries and no valid models: {self}')
+
+    def add_should(self, query: Query[M], *queries: Query[M]):
+        if self.mdl is None:
+            self.mdl = query.model
+        self.should.append(query)
+        self.should.extend(queries)
+
+    def add_must(self, query: Query[M], *queries: Query[M]):
+        if self.mdl is None:
+            self.mdl = query.model
+        self.must.append(query)
+        self.must.extend(queries)
+
+    def add_filter(self, query: Query[M], *queries: Query[M]):
+        if self.mdl is None:
+            self.mdl = query.model
+        self.filter.append(query)
+        self.filter.extend(queries)
+
+    def add_must_not(self, query: Query[M], *queries: Query[M]):
+        if self.mdl is None:
+            self.mdl = query.model
+        self.must_not.append(query)
+        self.must_not.extend(queries)
+
+class MatchQuery(Query[M]):
+    def __init__(self, select: Select[M, A], value: A, **options):
+        self.select = select
+        self.value = value
+        self.options = options
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {'match': {self.select.path: {'query': self.value}, **self.options}}
+
+    @property
+    def model(self) -> Type[M]:
+        return self.select.origin

pydoptic_elastic-0.0.1.post1.dev2/src/pydoptic_elastic/elastic_service.py

@@ -0,0 +1,73 @@
+from typing import List, Iterable, Any, Dict, Type
+
+from elasticsearch import Elasticsearch, NotFoundError
+
+from pydoptic import BaseModel, Select, PartialModel
+from pydoptic.selector import Prop
+from pydoptic_elastic.elastic_model import M
+from pydoptic_elastic.elastic_query import Query
+from pydoptic.base_model import select
+
+class _IndexResponse(BaseModel):
+    id: Prop['_IndexResponse', str] = select('_id')
+
+class _GetResponse(BaseModel):
+    id: Prop['_GetResponse', str] = select('_id')
+    doc: Prop['_GetResponse', Dict[str, Any]] = select('_source')
+
+class ElasticService:
+    def __init__(self, client: Elasticsearch):
+        self.__client = client
+
+    def create_index(self, model: Type[M]):
+        self.__client.indices.create(index=model._get_index_name(), mappings={'properties': model._get_mappings()})
+
+    def delete_index(self, model: Type[M]):
+        self.__client.indices.delete(index=model._get_index_name())
+
+    def refresh_index(self, model: Type[M]):
+        self.__client.indices.refresh(index=model._get_index_name())
+
+    def index(self, document: M, **kwargs) -> str:
+        response = self.__client.index(index=document.__class__._get_index_name(), document=document.as_dict_full(), **kwargs)
+        return _IndexResponse.id.get_val_unsafe(response.body)
+    
+    def get(self, cls: Type[M], id: str, **kwargs) -> M | None:
+        try:
+            response = self.__client.get(index = cls._get_index_name(), id=id, **kwargs)
+            return _GetResponse.doc.get_unsafe(response.body).map(lambda d: cls(**d)).as_opt
+        except NotFoundError:
+            return None
+        
+    def get_partial(self, cls: Type[M], id: str, **kwargs) -> PartialModel[M] | None:
+        try:
+            response = self.__client.get(index = cls._get_index_name(), id=id, **kwargs)
+            return _GetResponse.doc.get_unsafe(response.body).map(lambda d: cls.partial(**d)).as_opt
+        except NotFoundError:
+            return None
+        
+    def get_raw(self, cls: Type[M], id: str, **kwargs) -> Dict[str, Any] | None:
+        try:
+            response = self.__client.get(index = cls._get_index_name(), id=id, **kwargs)
+            return _GetResponse.doc.get_unsafe(response.body).as_opt
+        except NotFoundError:
+            return None
+
+    def search(self, query: Query[M], **kwargs) -> Iterable[M]:
+        search_results = self.__client.search(index = query.model._get_index_name(), query=query.to_dict(), **kwargs)
+        for hit in search_results['hits']['hits']:
+            _source = hit['_source']
+            yield query.model(**_source)
+
+    def search_partial(self, query: Query[M], source: Iterable[Select[M, Any]] | None = None, **kwargs) -> Iterable[PartialModel[M]]:
+        _kwargs = kwargs if source is None else {'source': [sel.path for sel in source], **kwargs}
+        search_results = self.__client.search(index=query.model._get_index_name(), query=query.to_dict(), **_kwargs)
+        for hit in search_results['hits']['hits']:
+            _source = hit['_source']
+            yield query.model.partial(**_source)
+
+    def search_raw(self, query: Query[M], source: Iterable[Select[M, Any]] | None = None, **kwargs) -> Iterable[Dict[str, Any]]:
+        _kwargs = kwargs if source is None else {'source': [sel.path for sel in source], **kwargs}
+        search_results = self.__client.search(index=query.model._get_index_name(), query=query.to_dict(), **_kwargs)
+        for hit in search_results['hits']['hits']:
+            yield hit['_source']

pydoptic_elastic-0.0.1.post1.dev2/src/pydoptic_elastic.egg-info/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: pydoptic-elastic
+Version: 0.0.1.post1.dev2
+Summary: An Elasticsearch integration built on pydoptic
+Author: John Hungerford
+License-Expression: MIT
+Project-URL: Source, https://github.com/johnhungerford/pydoptic
+Requires-Python: <3.14,>=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydoptic
+Requires-Dist: elasticsearch==8.14.0
+Provides-Extra: test
+Requires-Dist: pytest~=8.4.2; extra == "test"
+Provides-Extra: types
+Requires-Dist: mypy~=1.18.2; extra == "types"
+Dynamic: license-file
+
+# pydoptic-elastic
+
+An Elasticsearch integration built on [pydoptic](https://pypi.org/project/pydoptic/).
+
+`ElasticModel` captures index and field-mapping metadata directly on the model's `Prop`s, and `Query`
+lets you build Elasticsearch queries by referencing those `Prop`s directly -- no field or index names
+passed as bare strings.
+
+## Installation
+
+```bash
+pip install pydoptic-elastic
+```
+
+Includes the `elasticsearch` client as a regular dependency, so no extras are needed.
+
+## Quickstart
+
+```python3
+from pydoptic import Prop
+from pydoptic_elastic import ElasticModel, ElasticService, Query, elastic_prop, ESMapping
+from elasticsearch import Elasticsearch
+
+class Person(ElasticModel):
+    name: Prop['Person', str] = elastic_prop(mapping=ESMapping.keyword)
+    age: Prop['Person', int]
+
+service = ElasticService(Elasticsearch('http://localhost:9200'))
+service.create_index(Person)
+
+service.index(Person(name='John', age=42))
+
+query = Query.match(Person.name, 'John')
+for person in service.search(query):
+    print(Person.name.get_val(person))
+    # John
+
+# Retrieve only specific fields, as a PartialModel:
+for person in service.search_partial(query, source=[Person.name]):
+    print(Person.name.get_val_unsafe(person))
+    # John
+```
+
+See the [pydoptic README](https://github.com/johnhungerford/pydoptic/tree/main/packages/pydoptic) for
+the underlying `Prop`/`Select` model this is built on.

pydoptic_elastic-0.0.1.post1.dev2/src/pydoptic_elastic.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+src/pydoptic_elastic/__init__.py
+src/pydoptic_elastic/elastic_model.py
+src/pydoptic_elastic/elastic_query.py
+src/pydoptic_elastic/elastic_service.py
+src/pydoptic_elastic/py.typed
+src/pydoptic_elastic.egg-info/PKG-INFO
+src/pydoptic_elastic.egg-info/SOURCES.txt
+src/pydoptic_elastic.egg-info/dependency_links.txt
+src/pydoptic_elastic.egg-info/requires.txt
+src/pydoptic_elastic.egg-info/scm_file_list.json
+src/pydoptic_elastic.egg-info/scm_version.json
+src/pydoptic_elastic.egg-info/top_level.txt
+test/test_elastic_model.py
+test/test_elastic_service.py

pydoptic_elastic-0.0.1.post1.dev2/src/pydoptic_elastic.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pydoptic_elastic-0.0.1.post1.dev2/src/pydoptic_elastic.egg-info/requires.txt

@@ -0,0 +1,8 @@
+pydoptic
+elasticsearch==8.14.0
+
+[test]
+pytest~=8.4.2
+
+[types]
+mypy~=1.18.2

pydoptic_elastic-0.0.1.post1.dev2/src/pydoptic_elastic.egg-info/scm_file_list.json

@@ -0,0 +1,14 @@
+{
+  "files": [
+    "LICENSE",
+    "README.md",
+    "pyproject.toml",
+    "src/pydoptic_elastic/__init__.py",
+    "src/pydoptic_elastic/elastic_model.py",
+    "src/pydoptic_elastic/elastic_query.py",
+    "src/pydoptic_elastic/elastic_service.py",
+    "src/pydoptic_elastic/py.typed",
+    "test/test_elastic_model.py",
+    "test/test_elastic_service.py"
+  ]
+}

pydoptic_elastic-0.0.1.post1.dev2/src/pydoptic_elastic.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.0.1",
+  "distance": 2,
+  "node": "gf2a88e816d5622e7cf652ca9af0f07673483e3a0",
+  "dirty": false,
+  "branch": "main",
+  "node_date": "2026-08-18"
+}

pydoptic_elastic-0.0.1.post1.dev2/src/pydoptic_elastic.egg-info/top_level.txt

@@ -0,0 +1 @@
+pydoptic_elastic

pydoptic_elastic-0.0.1.post1.dev2/test/test_elastic_model.py

@@ -0,0 +1,33 @@
+from datetime import date, datetime
+from elasticsearch import Elasticsearch
+
+from pydoptic.selector import Prop, PropOptArr
+from pydoptic_elastic import ElasticModel, elastic_prop, ESMapping
+
+class Nested(ElasticModel):
+    prop_a: Prop['Nested', str] = elastic_prop(mapping=ESMapping.keyword)
+
+class SimpleModel(ElasticModel):
+    index_name = 'name_override'
+
+    prop_1: Prop['SimpleModel', str] = elastic_prop(mapping=ESMapping.text)
+    prop_2: Prop['SimpleModel', str]
+    prop_3: Prop['SimpleModel', int]
+    prop_4: Prop['SimpleModel', float]
+    prop_5: Prop['SimpleModel', bool]
+    prop_6: Prop['SimpleModel', date]
+    prop_7: Prop['SimpleModel', datetime]
+    prop_8: PropOptArr['SimpleModel', Nested]
+
+def test_elastic_model_mapping_should_reflect_custom_and_default_mappings():
+    mappings = SimpleModel._get_mappings()
+    assert mappings == {
+        'prop_1': {'type': 'text'},
+        'prop_2': {'type': 'text', 'fields': {'term': {'type': 'keyword'}}},
+        'prop_3': {'type': 'long'},
+        'prop_4': {'type': 'double'},
+        'prop_5': {'type': 'boolean'},
+        'prop_6': {'type': 'date'},
+        'prop_7': {'type': 'date'},
+        'prop_8': {'type': 'object', 'properties': {'prop_a': {'type': 'keyword'}}},
+    }

pydoptic_elastic-0.0.1.post1.dev2/test/test_elastic_service.py

@@ -0,0 +1,68 @@
+import pytest
+from elasticsearch import Elasticsearch
+
+from pydoptic.selector import Prop
+from pydoptic_elastic.elastic_model import ElasticModel
+from pydoptic_elastic.elastic_service import ElasticService
+from pydoptic_elastic.elastic_query import Query
+
+pytestmark = pytest.mark.integration
+
+class SimpleModel(ElasticModel):
+    prop_1: Prop['SimpleModel', int]
+    prop_2: Prop['SimpleModel', str]
+    prop_3: Prop['SimpleModel', bool]
+
+def test_index_and_retrieve_records():
+    client = Elasticsearch('http://localhost:9200')
+
+    service = ElasticService(client)
+
+    try:
+        service.create_index(SimpleModel)
+    except:
+        service.delete_index(SimpleModel)
+        service.create_index(SimpleModel)
+
+    try:
+        value = SimpleModel(prop_1=23, prop_2="hello", prop_3=True)
+
+        value_id = service.index(value)
+        service.refresh_index(SimpleModel)
+
+        value_retrieved = service.get(SimpleModel, value_id)
+
+        assert value_retrieved == value
+
+    finally:
+        service.delete_index(SimpleModel)
+
+def test_search_records():
+    client = Elasticsearch('http://localhost:9200')
+
+    service = ElasticService(client)
+
+    try:
+        service.create_index(SimpleModel)
+    except:
+        service.delete_index(SimpleModel)
+        service.create_index(SimpleModel)
+
+    try:
+        value_1 = SimpleModel(prop_1=23, prop_2="hello", prop_3=True)
+        value_2 = SimpleModel(prop_1=24, prop_2="world", prop_3=False)
+
+        service.index(value_1)
+        service.index(value_2)
+        service.refresh_index(SimpleModel)
+
+        query_1 = Query[SimpleModel].match(SimpleModel.prop_1, SimpleModel.prop_1.get_val(value_1))
+        res_1 = list(service.search(query_1))
+        assert res_1 == [value_1]
+
+        query_2 = Query[SimpleModel].match(SimpleModel.prop_1, SimpleModel.prop_1.get_val(value_2))
+        res_2 = list(service.search(query_2))
+        assert res_2 == [value_2]
+
+    finally:
+        service.delete_index(SimpleModel)