goodmem 0.1.2__tar.gz

goodmem-0.1.2/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: goodmem
+Version: 0.1.2
+Summary: GoodMem's Convenient SDK for Python
+Author-email: Forrest Bao <forrest@goodmem.ai>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/PAIR-Systems-Inc/goodmem
+Project-URL: Repository, https://github.com/PAIR-Systems-Inc/goodmem
+Project-URL: Documentation, https://docs.goodmem.ai
+Keywords: goodmem,memory,vector,embeddings,RAG,AI,Agents,LLMs,Rerankers,Embedders
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2
+Requires-Dist: python-dateutil>=2.8.2
+Requires-Dist: typing-extensions>=4.7.1
+Provides-Extra: dev
+Requires-Dist: pytest>=7.2.1; extra == "dev"
+Requires-Dist: pytest-cov>=2.8.1; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: mypy>=1.5; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+
+# GoodMem Python SDK II
+
+A Python SDK designed to be easy to use and easy to maintain. OpenAI-style API with auto-inference of model parameters, streaming retrieval, async support, and auto-pagination.
+
+To see how this SDK compares to the previous `goodmem-client` SDK, see [Then vs Now](docs/then_vs_now.md).
+
+## Installation
+
+At this point, we only publish to TestPyPI.
+```bash
+pip install --index-url https://test.pypi.org/simple/ goodmem
+```
+
+## Usage
+
+```python
+from goodmem import GoodMemClient
+
+client = GoodMemClient(
+    base_url="http://localhost:8080",
+    token="your-api-token"
+)
+
+embedder = client.embedders.create(
+    display_name="OpenAI Embedder",
+    model_identifier="text-embedding-3-large",
+    api_key="sk-your-openai-key",
+)
+
+print(f"Created: {embedder.embedder_id}")
+```
+
+## How It Works
+
+The SDK has two layers:
+
+- **Generated layer** (`goodmem/_generated/models/`) — Pydantic v2 models auto-generated from the server's OpenAPI spec via `openapi-generator`. These define request/response schemas.
+- **Convenience layer** (`goodmem/api/`, `goodmem/client.py`, etc.) — Hand-written wrapper that adds model registry auto-inference, parameter forwarding, streaming, pagination, and a clean client interface. Users never directly import from `_generated/`.
+
+The convenience layer transforms the raw generated SDK into something pleasant to use: `client.embedders.create(model_identifier="...", api_key="...")` instead of manually constructing nested request objects.
+
+## Documentation
+
+* [Build a basic RAG agent](docs/getting_started.md)
+* [API reference](docs/manual.md)
+* [Old vs new SDK](docs/then_vs_now.md)
+* [Design and maintenance guide](docs/design_and_maintenance.md) — for developers understanding the architecture and re-generation workflows
+
+
+## TODO
+
+1. Add CI/CD pipeline to publish to PyPI. Integrate into ../build_all.sh and build_client.sh.
+2. Add `gemini-embedding-001` to embedder registry once backend adds `OPENAI_COMPATIBLE` to `ProviderType`.
+3. Add Anthropic, Google, Cohere, and Mistral LLMs to registry once backend adds matching `LLMProviderType` values.

goodmem-0.1.2/README.md

@@ -0,0 +1,54 @@
+# GoodMem Python SDK II
+
+A Python SDK designed to be easy to use and easy to maintain. OpenAI-style API with auto-inference of model parameters, streaming retrieval, async support, and auto-pagination.
+
+To see how this SDK compares to the previous `goodmem-client` SDK, see [Then vs Now](docs/then_vs_now.md).
+
+## Installation
+
+At this point, we only publish to TestPyPI.
+```bash
+pip install --index-url https://test.pypi.org/simple/ goodmem
+```
+
+## Usage
+
+```python
+from goodmem import GoodMemClient
+
+client = GoodMemClient(
+    base_url="http://localhost:8080",
+    token="your-api-token"
+)
+
+embedder = client.embedders.create(
+    display_name="OpenAI Embedder",
+    model_identifier="text-embedding-3-large",
+    api_key="sk-your-openai-key",
+)
+
+print(f"Created: {embedder.embedder_id}")
+```
+
+## How It Works
+
+The SDK has two layers:
+
+- **Generated layer** (`goodmem/_generated/models/`) — Pydantic v2 models auto-generated from the server's OpenAPI spec via `openapi-generator`. These define request/response schemas.
+- **Convenience layer** (`goodmem/api/`, `goodmem/client.py`, etc.) — Hand-written wrapper that adds model registry auto-inference, parameter forwarding, streaming, pagination, and a clean client interface. Users never directly import from `_generated/`.
+
+The convenience layer transforms the raw generated SDK into something pleasant to use: `client.embedders.create(model_identifier="...", api_key="...")` instead of manually constructing nested request objects.
+
+## Documentation
+
+* [Build a basic RAG agent](docs/getting_started.md)
+* [API reference](docs/manual.md)
+* [Old vs new SDK](docs/then_vs_now.md)
+* [Design and maintenance guide](docs/design_and_maintenance.md) — for developers understanding the architecture and re-generation workflows
+
+
+## TODO
+
+1. Add CI/CD pipeline to publish to PyPI. Integrate into ../build_all.sh and build_client.sh.
+2. Add `gemini-embedding-001` to embedder registry once backend adds `OPENAI_COMPATIBLE` to `ProviderType`.
+3. Add Anthropic, Google, Cohere, and Mistral LLMs to registry once backend adds matching `LLMProviderType` values.

goodmem-0.1.2/goodmem/__init__.py

@@ -0,0 +1,28 @@
+"""GoodMem Python SDK."""
+
+from goodmem.client import AsyncGoodMemClient, GoodMemClient
+from goodmem.errors import (
+    APIError,
+    AuthenticationError,
+    ConflictError,
+    GoodMemError,
+    NotFoundError,
+    PermissionError,
+    RateLimitError,
+    ServerError,
+    ValidationError,
+)
+
+__all__ = [
+    "GoodMemClient",
+    "AsyncGoodMemClient",
+    "GoodMemError",
+    "APIError",
+    "AuthenticationError",
+    "PermissionError",
+    "NotFoundError",
+    "ConflictError",
+    "ValidationError",
+    "RateLimitError",
+    "ServerError",
+]

goodmem-0.1.2/goodmem/_base.py

@@ -0,0 +1,156 @@
+"""CRUDNamespace base class — eliminates repetition across CRUD API namespaces."""
+
+from __future__ import annotations
+
+from typing import Any, Generic, TypeVar
+
+import httpx
+
+from goodmem.errors import raise_for_status
+from goodmem.pagination import AsyncPaginator, Paginator
+
+T = TypeVar("T")
+
+
+class CRUDNamespace:
+    """Base class for standard CRUD API namespaces.
+
+    Subclasses set class-level attributes to define the resource type:
+
+        class EmbeddersAPI(CRUDNamespace):
+            _base_path = "/v1/embedders"
+            _create_model = EmbedderCreationRequest
+            _update_model = UpdateEmbedderRequest
+            _response_model = EmbedderResponse
+            _list_response_model = ListEmbeddersResponse
+    """
+
+    _base_path: str
+    _create_model: type | None = None
+    _update_model: type | None = None
+    _response_model: type | None = None
+    _list_response_model: type | None = None
+    _list_items_field: str = "items"
+
+    def __init__(self, http: httpx.Client, headers: dict[str, str]) -> None:
+        self._http = http
+        self._headers = headers
+
+    def create(self, **kwargs: Any) -> Any:
+        """Create a resource. Accepts model fields as kwargs."""
+        body = self._create_model.model_validate(kwargs)
+        resp = self._http.post(
+            self._base_path,
+            json=body.model_dump(by_alias=True, exclude_unset=True),
+            headers=self._headers,
+        )
+        return self._handle_response(resp, self._response_model)
+
+    def get(self, id: str) -> Any:
+        """Get a resource by ID."""
+        resp = self._http.get(
+            f"{self._base_path}/{id}",
+            headers=self._headers,
+        )
+        return self._handle_response(resp, self._response_model)
+
+    def list(self, **kwargs: Any) -> Paginator:
+        """List resources. Returns an auto-paginating iterator."""
+        return Paginator(
+            fetch_fn=lambda token: self._http.get(
+                self._base_path,
+                params={**kwargs, "nextToken": token} if token else kwargs or None,
+                headers=self._headers,
+            ),
+            response_model=self._list_response_model,
+            items_field=self._list_items_field,
+        )
+
+    def update(self, id: str, **kwargs: Any) -> Any:
+        """Update a resource by ID."""
+        body = self._update_model.model_validate(kwargs)
+        resp = self._http.put(
+            f"{self._base_path}/{id}",
+            json=body.model_dump(by_alias=True, exclude_unset=True),
+            headers=self._headers,
+        )
+        return self._handle_response(resp, self._response_model)
+
+    def delete(self, id: str) -> None:
+        """Delete a resource by ID."""
+        resp = self._http.delete(
+            f"{self._base_path}/{id}",
+            headers=self._headers,
+        )
+        raise_for_status(resp)
+
+    def _handle_response(self, resp: httpx.Response, model_cls: type | None) -> Any:
+        """Check status, raise typed exceptions, parse response."""
+        raise_for_status(resp)
+        if model_cls is None:
+            return None
+        return model_cls.model_validate(resp.json())
+
+
+class AsyncCRUDNamespace:
+    """Async base class for standard CRUD API namespaces."""
+
+    _base_path: str
+    _create_model: type | None = None
+    _update_model: type | None = None
+    _response_model: type | None = None
+    _list_response_model: type | None = None
+    _list_items_field: str = "items"
+
+    def __init__(self, http: httpx.AsyncClient, headers: dict[str, str]) -> None:
+        self._http = http
+        self._headers = headers
+
+    async def create(self, **kwargs: Any) -> Any:
+        body = self._create_model.model_validate(kwargs)
+        resp = await self._http.post(
+            self._base_path,
+            json=body.model_dump(by_alias=True, exclude_unset=True),
+            headers=self._headers,
+        )
+        return self._handle_response(resp, self._response_model)
+
+    async def get(self, id: str) -> Any:
+        resp = await self._http.get(
+            f"{self._base_path}/{id}",
+            headers=self._headers,
+        )
+        return self._handle_response(resp, self._response_model)
+
+    def list(self, **kwargs: Any) -> AsyncPaginator:
+        return AsyncPaginator(
+            fetch_fn=lambda token: self._http.get(
+                self._base_path,
+                params={**kwargs, "nextToken": token} if token else kwargs or None,
+                headers=self._headers,
+            ),
+            response_model=self._list_response_model,
+            items_field=self._list_items_field,
+        )
+
+    async def update(self, id: str, **kwargs: Any) -> Any:
+        body = self._update_model.model_validate(kwargs)
+        resp = await self._http.put(
+            f"{self._base_path}/{id}",
+            json=body.model_dump(by_alias=True, exclude_unset=True),
+            headers=self._headers,
+        )
+        return self._handle_response(resp, self._response_model)
+
+    async def delete(self, id: str) -> None:
+        resp = await self._http.delete(
+            f"{self._base_path}/{id}",
+            headers=self._headers,
+        )
+        raise_for_status(resp)
+
+    def _handle_response(self, resp: httpx.Response, model_cls: type | None) -> Any:
+        raise_for_status(resp)
+        if model_cls is None:
+            return None
+        return model_cls.model_validate(resp.json())

goodmem-0.1.2/goodmem/_generated/__init__.py

@@ -0,0 +1,2 @@
+# Auto-generated code from openapi-generator. DO NOT EDIT.
+# Re-generate with: library=httpx, --package-name goodmem._generated

goodmem-0.1.2/goodmem/_generated/models/__init__.py

@@ -0,0 +1,116 @@
+# coding: utf-8
+
+# flake8: noqa
+"""
+    GoodMem API
+
+    API for interacting with the GoodMem service, providing vector-based memory storage and retrieval with multiple embedder support. The service enables creation of memory spaces, storing memories with vector representations, and efficient similarity-based retrieval.
+
+    The version of the OpenAPI document: v1
+    Contact: support@goodmem.io
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+# import models into model package
+from goodmem._generated.models.abstract_reply import AbstractReply
+from goodmem._generated.models.active_license_metadata import ActiveLicenseMetadata
+from goodmem._generated.models.admin_drain_request import AdminDrainRequest
+from goodmem._generated.models.admin_drain_response import AdminDrainResponse
+from goodmem._generated.models.admin_purge_jobs_request import AdminPurgeJobsRequest
+from goodmem._generated.models.admin_purge_jobs_response import AdminPurgeJobsResponse
+from goodmem._generated.models.admin_reload_license_response import AdminReloadLicenseResponse
+from goodmem._generated.models.api_key_auth import ApiKeyAuth
+from goodmem._generated.models.api_key_response import ApiKeyResponse
+from goodmem._generated.models.background_job_attempt import BackgroundJobAttempt
+from goodmem._generated.models.background_job_summary import BackgroundJobSummary
+from goodmem._generated.models.batch_delete_memory_selector_request import BatchDeleteMemorySelectorRequest
+from goodmem._generated.models.batch_memory_creation_request import BatchMemoryCreationRequest
+from goodmem._generated.models.batch_memory_deletion_request import BatchMemoryDeletionRequest
+from goodmem._generated.models.batch_memory_response import BatchMemoryResponse
+from goodmem._generated.models.batch_memory_result import BatchMemoryResult
+from goodmem._generated.models.batch_memory_retrieval_request import BatchMemoryRetrievalRequest
+from goodmem._generated.models.binary_content import BinaryContent
+from goodmem._generated.models.bounding_box import BoundingBox
+from goodmem._generated.models.chunk_reference import ChunkReference
+from goodmem._generated.models.chunking_configuration import ChunkingConfiguration
+from goodmem._generated.models.context_item import ContextItem
+from goodmem._generated.models.create_api_key_request import CreateApiKeyRequest
+from goodmem._generated.models.create_api_key_response import CreateApiKeyResponse
+from goodmem._generated.models.create_llm_response import CreateLLMResponse
+from goodmem._generated.models.credential_kind import CredentialKind
+from goodmem._generated.models.distribution_type import DistributionType
+from goodmem._generated.models.document_timings import DocumentTimings
+from goodmem._generated.models.embedder_creation_request import EmbedderCreationRequest
+from goodmem._generated.models.embedder_response import EmbedderResponse
+from goodmem._generated.models.embedder_weight import EmbedderWeight
+from goodmem._generated.models.endpoint_authentication import EndpointAuthentication
+from goodmem._generated.models.error_detail import ErrorDetail
+from goodmem._generated.models.filtered_delete_memory_selector_request import FilteredDeleteMemorySelectorRequest
+from goodmem._generated.models.gcp_adc_auth import GcpAdcAuth
+from goodmem._generated.models.good_mem_status import GoodMemStatus
+from goodmem._generated.models.image_info import ImageInfo
+from goodmem._generated.models.llm_capabilities import LLMCapabilities
+from goodmem._generated.models.llm_creation_request import LLMCreationRequest
+from goodmem._generated.models.llm_provider_type import LLMProviderType
+from goodmem._generated.models.llm_response import LLMResponse
+from goodmem._generated.models.llm_sampling_params import LLMSamplingParams
+from goodmem._generated.models.llm_update_request import LLMUpdateRequest
+from goodmem._generated.models.length_measurement import LengthMeasurement
+from goodmem._generated.models.list_api_keys_response import ListApiKeysResponse
+from goodmem._generated.models.list_embedders_response import ListEmbeddersResponse
+from goodmem._generated.models.list_llms_response import ListLLMsResponse
+from goodmem._generated.models.list_rerankers_response import ListRerankersResponse
+from goodmem._generated.models.list_spaces_response import ListSpacesResponse
+from goodmem._generated.models.memory import Memory
+from goodmem._generated.models.memory_chunk_response import MemoryChunkResponse
+from goodmem._generated.models.memory_creation_request import MemoryCreationRequest
+from goodmem._generated.models.memory_list_response import MemoryListResponse
+from goodmem._generated.models.modality import Modality
+from goodmem._generated.models.ocr_category import OcrCategory
+from goodmem._generated.models.ocr_cell import OcrCell
+from goodmem._generated.models.ocr_document_request import OcrDocumentRequest
+from goodmem._generated.models.ocr_document_response import OcrDocumentResponse
+from goodmem._generated.models.ocr_input_format import OcrInputFormat
+from goodmem._generated.models.ocr_layout import OcrLayout
+from goodmem._generated.models.ocr_page import OcrPage
+from goodmem._generated.models.ocr_page_result import OcrPageResult
+from goodmem._generated.models.page_timings import PageTimings
+from goodmem._generated.models.ping_endpoint_info import PingEndpointInfo
+from goodmem._generated.models.ping_event import PingEvent
+from goodmem._generated.models.ping_notice import PingNotice
+from goodmem._generated.models.ping_once_request import PingOnceRequest
+from goodmem._generated.models.ping_payload_type import PingPayloadType
+from goodmem._generated.models.ping_result import PingResult
+from goodmem._generated.models.ping_stream_request import PingStreamRequest
+from goodmem._generated.models.ping_summary import PingSummary
+from goodmem._generated.models.ping_target_type import PingTargetType
+from goodmem._generated.models.ping_timing import PingTiming
+from goodmem._generated.models.post_processor import PostProcessor
+from goodmem._generated.models.processing_history import ProcessingHistory
+from goodmem._generated.models.provider_type import ProviderType
+from goodmem._generated.models.recursive_chunking_configuration import RecursiveChunkingConfiguration
+from goodmem._generated.models.reranker_creation_request import RerankerCreationRequest
+from goodmem._generated.models.reranker_response import RerankerResponse
+from goodmem._generated.models.result_set_boundary import ResultSetBoundary
+from goodmem._generated.models.retrieve_memory_event import RetrieveMemoryEvent
+from goodmem._generated.models.retrieve_memory_request import RetrieveMemoryRequest
+from goodmem._generated.models.retrieved_item import RetrievedItem
+from goodmem._generated.models.rpc_status import RpcStatus
+from goodmem._generated.models.secret_reference import SecretReference
+from goodmem._generated.models.sentence_chunking_configuration import SentenceChunkingConfiguration
+from goodmem._generated.models.separator_keep_strategy import SeparatorKeepStrategy
+from goodmem._generated.models.space import Space
+from goodmem._generated.models.space_creation_request import SpaceCreationRequest
+from goodmem._generated.models.space_embedder import SpaceEmbedder
+from goodmem._generated.models.space_embedder_config import SpaceEmbedderConfig
+from goodmem._generated.models.space_key import SpaceKey
+from goodmem._generated.models.system_info_response import SystemInfoResponse
+from goodmem._generated.models.system_init_response import SystemInitResponse
+from goodmem._generated.models.update_api_key_request import UpdateApiKeyRequest
+from goodmem._generated.models.update_embedder_request import UpdateEmbedderRequest
+from goodmem._generated.models.update_reranker_request import UpdateRerankerRequest
+from goodmem._generated.models.update_space_request import UpdateSpaceRequest
+from goodmem._generated.models.user_response import UserResponse

goodmem-0.1.2/goodmem/_generated/models/abstract_reply.py

@@ -0,0 +1,97 @@
+# coding: utf-8
+
+"""
+    GoodMem API
+
+    API for interacting with the GoodMem service, providing vector-based memory storage and retrieval with multiple embedder support. The service enables creation of memory spaces, storing memories with vector representations, and efficient similarity-based retrieval.
+
+    The version of the OpenAPI document: v1
+    Contact: support@goodmem.io
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AbstractReply(BaseModel):
+    """
+    Generated abstractive reply with relevance information
+    """ # noqa: E501
+    text: StrictStr = Field(description="Generated abstractive reply text")
+    relevance_score: Union[StrictFloat, StrictInt] = Field(description="Relevance score for this reply (0.0 to 1.0)", alias="relevanceScore")
+    result_set_id: Optional[StrictStr] = Field(default=None, description="Optional result set ID linking this abstract to a specific result set", alias="resultSetId")
+    __properties: ClassVar[List[str]] = ["text", "relevanceScore", "resultSetId"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of AbstractReply from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # set to None if result_set_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.result_set_id is None and "result_set_id" in self.model_fields_set:
+            _dict['resultSetId'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AbstractReply from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "text": obj.get("text"),
+            "relevanceScore": obj.get("relevanceScore"),
+            "resultSetId": obj.get("resultSetId")
+        })
+        return _obj
+
+

goodmem-0.1.2/goodmem/_generated/models/active_license_metadata.py

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+    GoodMem API
+
+    API for interacting with the GoodMem service, providing vector-based memory storage and retrieval with multiple embedder support. The service enables creation of memory spaces, storing memories with vector representations, and efficient similarity-based retrieval.
+
+    The version of the OpenAPI document: v1
+    Contact: support@goodmem.io
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ActiveLicenseMetadata(BaseModel):
+    """
+    ActiveLicenseMetadata
+    """ # noqa: E501
+    filename: Optional[StrictStr] = None
+    sha256: Optional[StrictStr] = None
+    size_bytes: StrictInt = Field(alias="sizeBytes")
+    modified_at: Optional[datetime] = Field(default=None, alias="modifiedAt")
+    __properties: ClassVar[List[str]] = ["filename", "sha256", "sizeBytes", "modifiedAt"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ActiveLicenseMetadata from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ActiveLicenseMetadata from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "filename": obj.get("filename"),
+            "sha256": obj.get("sha256"),
+            "sizeBytes": obj.get("sizeBytes"),
+            "modifiedAt": obj.get("modifiedAt")
+        })
+        return _obj
+
+