shopware-api-client 1.1.1__tar.gz → 1.1.5__tar.gz

{shopware_api_client-1.1.1 → shopware_api_client-1.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shopware-api-client
-Version: 1.1.1
+Version: 1.1.5
 Summary:  An api client for the Shopware API
 License: MIT
 License-File: LICENSE

{shopware_api_client-1.1.1 → shopware_api_client-1.1.5}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "shopware-api-client"
 description = " An api client for the Shopware API"
-version = "1.1.1"
+version = "1.1.5"
 license = "MIT"
 authors = ["GWS Gesellschaft für Warenwirtschafts-Systeme mbH <ebusiness@gws.ms>"]
 readme = "README.md"

{shopware_api_client-1.1.1 → shopware_api_client-1.1.5}/src/shopware_api_client/base.py

@@ -11,6 +11,7 @@ from typing import (
     AsyncGenerator,
     Callable,
     Generic,
+    Literal,
     Self,
     Type,
     TypeVar,
@@ -27,9 +28,9 @@ from pydantic import (
     BaseModel,
     ConfigDict,
     Field,
+    PydanticUserError,
     ValidationError,
     model_serializer,
-    PydanticUserError,
 )
 from pydantic.alias_generators import to_camel
 from pydantic.main import IncEx
@@ -393,7 +394,16 @@ class EndpointMixin(Generic[EndpointClass]):
         return endpoint
 
 
-class ApiModelBase(BaseModel):
+class ApiModelBaseFields(BaseModel):
+    id: "IdField | None" = None
+    version_id: IdField | None = None
+    translated: dict[str, Any] | list[Any] | None = None
+    created_at: AwareDatetime | None = Field(default_factory=lambda: datetime.now(UTC), exclude=True)
+    updated_at: AwareDatetime | None = Field(default=None, exclude=True)
+    extensions: dict[str, Any] | None = Field(default=None, exclude=True)
+
+
+class ApiModelBase(ApiModelBaseFields):
     model_config = ConfigDict(
         alias_generator=AliasGenerator(
             validation_alias=lambda field_name: AliasChoices(field_name, to_camel(field_name)),
@@ -402,12 +412,6 @@ class ApiModelBase(BaseModel):
         validate_assignment=True,
     )
 
-    id: "IdField | None" = None
-    version_id: IdField | None = None
-    translated: dict[str, Any] | list[Any] | None = None
-    created_at: AwareDatetime | None = Field(default_factory=lambda: datetime.now(UTC), exclude=True)
-    updated_at: AwareDatetime | None = Field(default=None, exclude=True)
-
     def __init__(self, client: ClientBase | None = None, **kwargs: dict[str, Any]) -> None:
         self._insert_translations(
             data=kwargs,
@@ -415,10 +419,10 @@ class ApiModelBase(BaseModel):
         )
 
         try:
-            super().__init__(**kwargs)
+            BaseModel.__init__(self, **kwargs)
         except PydanticUserError:
             self.model_rebuild()
-            super().__init__(**kwargs)
+            BaseModel.__init__(self, **kwargs)
 
         # Pydantic doesn't do a good job at calling the parents, so we have to help
         if isinstance(self, EndpointMixin):
@@ -601,7 +605,10 @@ class EndpointSearchMixin(Generic[ModelClass]):
         if name == getattr(self.model_class, "_identifier").get_default():
             return name
 
-        field = self.model_class.model_fields[name]
+        if name in self.model_class.model_fields:
+            field = self.model_class.model_fields[name]
+        else:
+            return cast(str, to_camel(name))
 
         if get_origin(field.annotation) in [ForeignRelation, ManyRelation]:
             return cast(str, to_camel(name))
@@ -762,7 +769,19 @@ class AdminEndpoint(EndpointBase, EndpointSearchMixin, Generic[AdminModelClass])
 
         return result_list
 
-    async def all(self) -> list[AdminModelClass] | list[dict[str, Any]]:
+    @overload
+    async def all(self, raw: Literal[False]) -> list[AdminModelClass]: ...
+
+    @overload
+    async def all(self, raw: Literal[True]) -> list[dict[str, Any]]: ...
+
+    @overload
+    async def all(self, raw: bool) -> list[AdminModelClass] | list[dict[str, Any]]: ...
+
+    @overload
+    async def all(self) -> list[AdminModelClass]: ...
+
+    async def all(self, raw: bool = False) -> list[AdminModelClass] | list[dict[str, Any]]:
         data = self._get_data_dict()
 
         if self._is_search_query():
@@ -774,22 +793,51 @@ class AdminEndpoint(EndpointBase, EndpointSearchMixin, Generic[AdminModelClass])
 
         self._reset_endpoint()
 
-        if self.raw:
+        if self.raw or raw:
             return result_data
 
         return self._parse_response(result_data)
 
-    async def get(self, pk: str) -> AdminModelClass | dict[str, Any]:
+    @overload
+    async def get(self, pk: str, raw: Literal[False]) -> AdminModelClass: ...
+
+    @overload
+    async def get(self, pk: str, raw: Literal[True]) -> dict[str, Any]: ...
+
+    @overload
+    async def get(self, pk: str) -> AdminModelClass: ...
+
+    async def get(self, pk: str, raw: bool = False) -> AdminModelClass | dict[str, Any]:
         result = await self.client.get(f"{self.path}/{pk}")
         result_data: dict[str, Any] = self._parse_data_single(result.json())
 
-        if self.raw:
+        if self.raw or raw:
             return result_data
 
         return self._parse_response(result_data)
 
+    @overload
+    async def update(
+        self, pk: str, obj: AdminModelClass | dict[str, Any], update_fields: IncEx | None, raw: Literal[False]
+    ) -> AdminModelClass | None: ...
+
+    @overload
     async def update(
-            self, pk: str, obj: AdminModelClass | dict[str, Any], update_fields: IncEx | None = None
+        self, pk: str, obj: AdminModelClass | dict[str, Any], update_fields: IncEx | None, raw: Literal[True]
+    ) -> dict[str, Any] | None: ...
+
+    @overload
+    async def update(
+        self, pk: str, obj: AdminModelClass | dict[str, Any], update_fields: IncEx | None
+    ) -> AdminModelClass | None: ...
+
+    @overload
+    async def update(
+        self, pk: str, obj: AdminModelClass | dict[str, Any]
+    ) -> AdminModelClass | None: ...
+
+    async def update(
+        self, pk: str, obj: AdminModelClass | dict[str, Any], update_fields: IncEx | None = None, raw: bool = False
     ) -> AdminModelClass | dict[str, Any] | None:
         if isinstance(obj, ApiModelBase):
             data = obj.model_dump_json(by_alias=True, include=update_fields)
@@ -803,14 +851,23 @@ class AdminEndpoint(EndpointBase, EndpointSearchMixin, Generic[AdminModelClass])
 
         result_data: dict[str, Any] = self._parse_data_single(result.json())
 
-        if self.raw:
+        if self.raw or raw:
             return result_data
 
         return self._parse_response(result_data)
 
-    async def first(self) -> AdminModelClass | dict[str, Any] | None:
+    @overload
+    async def first(self, raw: Literal[False]) -> AdminModelClass | None: ...
+
+    @overload
+    async def first(self, raw: Literal[True]) -> dict[str, Any] | None: ...
+
+    @overload
+    async def first(self) -> AdminModelClass | None: ...
+
+    async def first(self, raw: bool = False) -> AdminModelClass | dict[str, Any] | None:
         self._limit = 1
-        result = await self.all()
+        result = await self.all(raw=raw)
 
         self._reset_endpoint()
 
@@ -820,7 +877,19 @@ class AdminEndpoint(EndpointBase, EndpointSearchMixin, Generic[AdminModelClass])
 
         return result[0]
 
-    async def create(self, obj: AdminModelClass | dict[str, Any]) -> AdminModelClass | dict[str, Any] | None:
+    @overload
+    async def create(self, obj: AdminModelClass | dict[str, Any], raw: Literal[False]) -> AdminModelClass | None: ...
+
+    @overload
+    async def create(self, obj: AdminModelClass | dict[str, Any], raw: Literal[True]) -> dict[str, Any] | None: ...
+
+    @overload
+    async def create(self, obj: AdminModelClass | dict[str, Any], raw: bool) -> AdminModelClass | dict[str, Any] | None: ...
+
+    @overload
+    async def create(self, obj: AdminModelClass | dict[str, Any]) -> AdminModelClass | None: ...
+
+    async def create(self, obj: AdminModelClass | dict[str, Any], raw: bool = False) -> AdminModelClass | dict[str, Any] | None:
         if isinstance(obj, ApiModelBase):
             data = obj.model_dump_json(by_alias=True)
         else:
@@ -833,7 +902,7 @@ class AdminEndpoint(EndpointBase, EndpointSearchMixin, Generic[AdminModelClass])
 
         result_data: dict[str, Any] = self._parse_data_single(result.json())
 
-        if self.raw:
+        if self.raw or raw:
             return result_data
 
         return self._parse_response(result_data)
@@ -846,12 +915,24 @@ class AdminEndpoint(EndpointBase, EndpointSearchMixin, Generic[AdminModelClass])
 
         return False
 
-    async def get_related(self, parent: AdminModelClass, relation: str) -> list[AdminModelClass] | list[dict[str, Any]]:
+    @overload
+    async def get_related(self, parent: AdminModel[Any], relation: str, raw: Literal[False]) -> list[AdminModelClass]: ...
+
+    @overload
+    async def get_related(self, parent: AdminModel[Any], relation: str, raw: Literal[True]) -> list[dict[str, Any]]: ...
+
+    @overload
+    async def get_related(self, parent: AdminModel[Any], relation: str, raw: bool) -> list[AdminModelClass] | list[dict[str, Any]]: ...
+
+    @overload
+    async def get_related(self, parent: AdminModel[Any], relation: str) -> list[AdminModelClass]: ...
+
+    async def get_related(self, parent: AdminModel[Any], relation: str, raw: bool = False) -> list[AdminModelClass] | list[dict[str, Any]]:
         parent_endpoint = parent._get_endpoint()
         result = await self.client.get(f"{parent_endpoint.path}/{parent.id}/{relation}")
         result_data: list[dict[str, Any]] = self._parse_data(result.json())
 
-        if self.raw:
+        if self.raw or raw:
             return result_data
 
         return self._parse_response(result_data)
@@ -866,7 +947,7 @@ class AdminEndpoint(EndpointBase, EndpointSearchMixin, Generic[AdminModelClass])
     ) -> dict[str, Any]:
         return await self.client.bulk_delete(name=self.name, objs=objs, fail_silently=fail_silently, **request_kwargs)
 
-    async def iter(self, batch_size: int = 100) -> AsyncGenerator[AdminModelClass | dict[str, Any], None]:
+    async def iter(self, batch_size: int = 100, raw: bool = False) -> AsyncGenerator[AdminModelClass | dict[str, Any], None]:
         self._limit = batch_size
         data = self._get_data_dict()
         page = 1
@@ -887,7 +968,7 @@ class AdminEndpoint(EndpointBase, EndpointSearchMixin, Generic[AdminModelClass])
             result_data: list[dict[str, Any]] = self._parse_data(result_dict)
 
             for entry in result_data:
-                if self.raw:
+                if self.raw or raw:
                     yield entry
                 else:
                     yield self._parse_response(entry)
@@ -951,19 +1032,28 @@ class StoreEndpoint(EndpointBase):
 class StoreSearchEndpoint(StoreEndpoint, EndpointSearchMixin, Generic[ModelClass]):
     path: str
 
-    async def all(self) -> list[ModelClass] | list[dict[str, Any]]:
+    @overload
+    async def all(self, raw: Literal[False]) -> list[ModelClass]: ...
+
+    @overload
+    async def all(self, raw: Literal[True]) -> list[dict[str, Any]]: ...
+
+    @overload
+    async def all(self, raw: bool) -> list[ModelClass] | list[dict[str, Any]]: ...
+
+    async def all(self, raw: bool = False) -> list[ModelClass] | list[dict[str, Any]]:
         data = self._get_data_dict()
 
         result = await self.client.post(self.path, json=data)
 
         result_data: list[dict[str, Any]] = result.json().get("elements", [])
 
-        if self.raw:
+        if self.raw or raw:
             return result_data
 
         return self._parse_response(result_data, cls=self.model_class)
 
-    async def iter(self, batch_size: int = 100) -> AsyncGenerator[ModelClass | dict[str, Any], None]:
+    async def iter(self, batch_size: int = 100, raw: bool = False) -> AsyncGenerator[ModelClass | dict[str, Any], None]:
         self._limit = batch_size
         data = self._get_data_dict()
         page = 1
@@ -976,7 +1066,7 @@ class StoreSearchEndpoint(StoreEndpoint, EndpointSearchMixin, Generic[ModelClass
             result_data: list[dict[str, Any]] = self._parse_data(result_dict)
 
             for entry in result_data:
-                if self.raw:
+                if self.raw or raw:
                     yield entry
                 else:
                     yield self._parse_response(entry, cls=self.model_class)
@@ -986,9 +1076,18 @@ class StoreSearchEndpoint(StoreEndpoint, EndpointSearchMixin, Generic[ModelClass
             else:
                 break
 
-    async def first(self) -> ModelClass | dict[str, Any] | None:
+    @overload
+    async def first(self, raw: Literal[False]) -> ModelClass | None: ...
+
+    @overload
+    async def first(self, raw: Literal[True]) -> dict[str, Any] | None: ...
+
+    @overload
+    async def first(self, raw: bool) -> ModelClass | dict[str, Any] | None: ...
+
+    async def first(self, raw: bool = False) -> ModelClass | dict[str, Any] | None:
         self._limit = 1
-        result = await self.all()
+        result = await self.all(raw=raw)
 
         self._reset_endpoint()
 

{shopware_api_client-1.1.1 → shopware_api_client-1.1.5}/src/shopware_api_client/endpoints/admin/commercial/b2b_components_role.py

@@ -1,11 +1,13 @@
+from pydantic import Field
+
 from shopware_api_client.base import AdminEndpoint, AdminModel
 from shopware_api_client.endpoints.relations import ForeignRelation, ManyRelation
 from shopware_api_client.models.b2b_components_role import B2bComponentsRoleBase
 
 
 class B2bComponentsRole(B2bComponentsRoleBase, AdminModel["B2bComponentsRoleEndpoint"]):
-    employees: ManyRelation["B2bEmployee"]
-    business_partner_customer: ForeignRelation["Customer"]
+    employees: ManyRelation["B2bEmployee"] = Field(default=...)
+    business_partner_customer: ForeignRelation["Customer"] = Field(default=...)
 
 
 class B2bComponentsRoleEndpoint(AdminEndpoint[B2bComponentsRole]):

{shopware_api_client-1.1.1 → shopware_api_client-1.1.5}/src/shopware_api_client/endpoints/admin/commercial/b2b_components_shopping_list.py

@@ -1,13 +1,15 @@
+from pydantic import Field
+
 from shopware_api_client.base import AdminModel, AdminEndpoint
 from shopware_api_client.endpoints.relations import ForeignRelation, ManyRelation
 from shopware_api_client.models.b2b_components_shopping_list import B2bComponentsShoppingListBase
 
 
 class B2bComponentsShoppingList(B2bComponentsShoppingListBase, AdminModel["B2bComponentsShoppingListEndpoint"]):
-    sales_channel: ForeignRelation["SalesChannel"]
-    line_items: ManyRelation["B2bComponentsShoppingListLineItem"]
-    customer: ForeignRelation["Customer"]
-    employee: ForeignRelation["B2bEmployee"]
+    sales_channel: ForeignRelation["SalesChannel"] = Field(default=...)
+    line_items: ManyRelation["B2bComponentsShoppingListLineItem"] = Field(default=...)
+    customer: ForeignRelation["Customer"] = Field(default=...)
+    employee: ForeignRelation["B2bEmployee"] = Field(default=...)
 
 
 class B2bComponentsShoppingListEndpoint(AdminEndpoint[B2bComponentsShoppingList]):

{shopware_api_client-1.1.1 → shopware_api_client-1.1.5}/src/shopware_api_client/endpoints/admin/commercial/b2b_components_shopping_list_line_item.py

@@ -1,3 +1,5 @@
+from pydantic import Field
+
 from shopware_api_client.base import AdminModel, AdminEndpoint
 from shopware_api_client.endpoints.relations import ForeignRelation
 from shopware_api_client.models.b2b_components_shopping_list_line_item import B2bComponentsShoppingListLineItemBase
@@ -6,8 +8,8 @@ from shopware_api_client.models.b2b_components_shopping_list_line_item import B2
 class B2bComponentsShoppingListLineItem(
     B2bComponentsShoppingListLineItemBase, AdminModel["B2bComponentsShoppingListLineItemEndpoint"]
 ):
-    shopping_list: ForeignRelation["B2bComponentsShoppingList"]
-    product: ForeignRelation["Product"]
+    shopping_list: ForeignRelation["B2bComponentsShoppingList"] = Field(default=...)
+    product: ForeignRelation["Product"] = Field(default=...)
 
 
 class B2bComponentsShoppingListLineItemEndpoint(AdminEndpoint[B2bComponentsShoppingListLineItem]):

{shopware_api_client-1.1.1 → shopware_api_client-1.1.5}/src/shopware_api_client/endpoints/admin/commercial/b2b_employee.py

@@ -1,12 +1,14 @@
+from pydantic import Field
+
 from shopware_api_client.base import AdminEndpoint, AdminModel
 from shopware_api_client.endpoints.relations import ForeignRelation
 from shopware_api_client.models.b2b_employee import B2bEmployeeBase
 
 
 class B2bEmployee(B2bEmployeeBase, AdminModel["B2bEmployeeEndpoint"]):
-    business_partner_customer: ForeignRelation["Customer"]
-    role: ForeignRelation["B2bComponentsRole"]
-    language: ForeignRelation["Language"]
+    business_partner_customer: ForeignRelation["Customer"] = Field(default=...)
+    role: ForeignRelation["B2bComponentsRole"] = Field(default=...)
+    language: ForeignRelation["Language"] = Field(default=...)
 
 
 class B2bEmployeeEndpoint(AdminEndpoint[B2bEmployee]):

{shopware_api_client-1.1.1 → shopware_api_client-1.1.5}/src/shopware_api_client/endpoints/admin/commercial/dynamic_access.py

@@ -1,11 +1,13 @@
+from pydantic import Field
+
 from shopware_api_client.base import AdminEndpoint, AdminModel
 from shopware_api_client.endpoints.relations import ForeignRelation
 from shopware_api_client.models.dynamic_access import DynamicAccessBase
 
 
 class DynamicAccess(DynamicAccessBase, AdminModel["DynamicAccessEndpoint"]):
-    product: ForeignRelation["Product"]
-    rule: ForeignRelation["Rule"]
+    product: ForeignRelation["Product"] = Field(default=...)
+    rule: ForeignRelation["Rule"] = Field(default=...)
 
 
 class DynamicAccessEndpoint(AdminEndpoint[DynamicAccess]):

{shopware_api_client-1.1.1 → shopware_api_client-1.1.5}/src/shopware_api_client/endpoints/admin/core/acl_role.py

@@ -1,12 +1,14 @@
+from pydantic import Field
+
 from shopware_api_client.base import AdminEndpoint, AdminModel
 from shopware_api_client.endpoints.relations import ForeignRelation, ManyRelation
 from shopware_api_client.models.acl_role import AclRoleBase
 
 
 class AclRole(AclRoleBase, AdminModel["AclRoleEndpoint"]):
-    users: ManyRelation["User"]
-    app: ForeignRelation["App"]
-    integrations: ManyRelation["Integration"]
+    users: ManyRelation["User"] = Field(default=...)
+    app: ForeignRelation["App"] = Field(default=...)
+    integrations: ManyRelation["Integration"] = Field(default=...)
 
 
 class AclRoleEndpoint(AdminEndpoint[AclRole]):

shopware_api_client-1.1.5/src/shopware_api_client/endpoints/admin/core/api_info.py

@@ -0,0 +1,106 @@
+from typing import Any, Literal, overload
+
+from pydantic import BaseModel, Field
+from pydantic.main import IncEx
+
+from shopware_api_client.base import AdminEndpoint, AdminModel
+from shopware_api_client.exceptions import SWAPIMethodNotAvailable
+
+
+class Bundle(BaseModel):
+    css: list[str]
+    js: list[str]
+    baseUrl: str | None = None
+    type: str
+
+
+class AppBundle(BaseModel):
+    active: bool
+    integrationId: str
+    type: str
+    baseUrl: str
+    permissions: dict[str, list[str]]
+    version: str
+    name: str
+
+
+class ApiInfo(AdminModel["ApiInfoEndpoint"]):
+    _identifier = "api_info"
+
+    version: str
+    version_revision: str
+    admin_worker: dict[str, Any]
+    bundles: dict[str, Bundle | AppBundle]
+    settings: dict[str, Any]
+    license_toggles: dict[str, bool] | None = Field(default=None)
+
+
+class ApiInfoEndpoint(AdminEndpoint[ApiInfo]):
+    name = "adminWorker"
+    path = "/_info/config"
+    model_class = ApiInfo
+
+    async def delete(self, pk: str) -> bool:
+        raise SWAPIMethodNotAvailable()
+
+    @overload
+    async def get(self, pk: str, raw: Literal[False]) -> ApiInfo: ...
+
+    @overload
+    async def get(self, pk: str, raw: Literal[True]) -> dict[str, Any]: ...
+
+    @overload
+    async def get(self, pk: str) -> ApiInfo: ...
+
+    async def get(self, pk: str, raw: bool = False) -> ApiInfo | dict[str, Any]:
+        raise SWAPIMethodNotAvailable()
+
+    @overload
+    async def create(self, obj: ApiInfo | dict[str, Any], raw: Literal[False]) -> ApiInfo | None: ...
+
+    @overload
+    async def create(self, obj: ApiInfo | dict[str, Any], raw: Literal[True]) -> dict[str, Any] | None: ...
+
+    @overload
+    async def create(self, obj: ApiInfo | dict[str, Any], raw: bool) -> ApiInfo | dict[str, Any] | None: ...
+
+    @overload
+    async def create(self, obj: ApiInfo | dict[str, Any]) -> ApiInfo | None: ...
+
+    async def create(self, obj: ApiInfo | dict[str, Any], raw: bool = False) -> ApiInfo | dict[str, Any] | None:
+        raise SWAPIMethodNotAvailable()
+
+    @overload
+    async def update(
+        self, pk: str, obj: ApiInfo | dict[str, Any], update_fields: IncEx | None, raw: Literal[False]
+    ) -> ApiInfo | None: ...
+
+    @overload
+    async def update(
+        self, pk: str, obj: ApiInfo | dict[str, Any], update_fields: IncEx | None, raw: Literal[True]
+    ) -> dict[str, Any] | None: ...
+
+    @overload
+    async def update(
+        self, pk: str, obj: ApiInfo | dict[str, Any], update_fields: IncEx | None
+    ) -> ApiInfo | None: ...
+
+    @overload
+    async def update(
+        self, pk: str, obj: ApiInfo | dict[str, Any]
+    ) -> ApiInfo | None: ...
+
+    async def update(
+        self, pk: str, obj: ApiInfo | dict[str, Any], update_fields: IncEx | None = None, raw: bool = False
+    ) -> ApiInfo | dict[str, Any] | None:
+        raise SWAPIMethodNotAvailable()
+
+    async def bulk_upsert(
+        self, objs: list[ApiInfo] | list[dict[str, Any]], fail_silently: bool = False, **request_kwargs: Any
+    ) -> dict[str, Any]:
+        raise SWAPIMethodNotAvailable()
+
+    async def bulk_delete(
+        self, objs: list[ApiInfo] | list[dict[str, Any]], fail_silently: bool = False, **request_kwargs: Any
+    ) -> dict[str, Any]:
+        raise SWAPIMethodNotAvailable()

{shopware_api_client-1.1.1 → shopware_api_client-1.1.5}/src/shopware_api_client/endpoints/admin/core/app.py

@@ -1,12 +1,14 @@
+from pydantic import Field
+
 from shopware_api_client.base import AdminEndpoint, AdminModel
 from shopware_api_client.endpoints.relations import ForeignRelation, ManyRelation
 from shopware_api_client.models.app import AppBase
 
 
 class App(AppBase, AdminModel["AppEndpoint"]):
-    app: ForeignRelation["App"]
-    acl_roles: ManyRelation["AclRole"]
-    integrations: ManyRelation["Integration"]
+    app: ForeignRelation["App"] = Field(default=...)
+    acl_roles: ManyRelation["AclRole"] = Field(default=...)
+    integrations: ManyRelation["Integration"] = Field(default=...)
 
 
 class AppEndpoint(AdminEndpoint[App]):

{shopware_api_client-1.1.1 → shopware_api_client-1.1.5}/src/shopware_api_client/endpoints/admin/core/app_script_condition.py

@@ -1,11 +1,13 @@
+from pydantic import Field
+
 from shopware_api_client.base import AdminEndpoint, AdminModel
 from shopware_api_client.endpoints.relations import ForeignRelation, ManyRelation
 from shopware_api_client.models.app_script_condition import AppScriptConditionBase
 
 
 class AppScriptCondition(AppScriptConditionBase, AdminModel["AppScriptConditionEndpoint"]):
-    app: ForeignRelation["App"]
-    rule_conditions: ManyRelation["RuleCondition"]
+    app: ForeignRelation["App"] = Field(default=...)
+    rule_conditions: ManyRelation["RuleCondition"] = Field(default=...)
 
 
 class AppScriptConditionEndpoint(AdminEndpoint[AppScriptCondition]):

shopware_api_client-1.1.5/src/shopware_api_client/endpoints/admin/core/category.py

@@ -0,0 +1,37 @@
+from pydantic import Field
+
+from shopware_api_client.base import AdminEndpoint, AdminModel
+from shopware_api_client.endpoints.relations import ForeignRelation, ManyRelation
+from shopware_api_client.models.category import CategoryBase
+
+
+class Category(CategoryBase, AdminModel["CategoryEndpoint"]):
+    parent: ForeignRelation["Category"] = Field(default=...)
+    children: ManyRelation["Category"] = Field(default=...)
+    media: ForeignRelation["Media"] = Field(default=...)
+    products: ManyRelation["Product"] = Field(default=...)
+    nested_products: ManyRelation["Product"] = Field(default=...)
+    tags: ManyRelation["Tag"] = Field(default=...)
+    cms_page: ForeignRelation["CmsPage"] = Field(default=...)
+    product_stream: ForeignRelation["ProductStream"] = Field(default=...)
+    navigation_sales_channels: ManyRelation["SalesChannel"] = Field(default=...)
+    footer_sales_channels: ManyRelation["SalesChannel"] = Field(default=...)
+    service_sales_channels: ManyRelation["SalesChannel"] = Field(default=...)
+    main_categories: ManyRelation["MainCategory"] = Field(default=...)
+    seo_urls: ManyRelation["SeoUrl"] = Field(default=...)
+
+
+class CategoryEndpoint(AdminEndpoint[Category]):
+    name = "category"
+    path = "/category"
+    model_class = Category
+
+
+from .cms_page import CmsPage  # noqa: E402
+from .main_category import MainCategory  # noqa: E402
+from .media import Media  # noqa: E402
+from .product import Product  # noqa: E402
+from .product_stream import ProductStream  # noqa: E402
+from .sales_channel import SalesChannel  # noqa: E402
+from .seo_url import SeoUrl  # noqa: E402
+from .tag import Tag  # noqa: E402

{shopware_api_client-1.1.1 → shopware_api_client-1.1.5}/src/shopware_api_client/endpoints/admin/core/cms_block.py

@@ -1,12 +1,14 @@
+from pydantic import Field
+
 from shopware_api_client.base import AdminModel, AdminEndpoint
 from shopware_api_client.endpoints.relations import ForeignRelation, ManyRelation
 from shopware_api_client.models.cms_block import CmsBlockBase
 
 
 class CmsBlock(CmsBlockBase, AdminModel["CmsBlockEndpoint"]):
-    section: ForeignRelation["CmsSection"]
-    background_media: ForeignRelation["Media"]
-    slots: ManyRelation["CmsSlot"]
+    section: ForeignRelation["CmsSection"] = Field(default=...)
+    background_media: ForeignRelation["Media"] = Field(default=...)
+    slots: ManyRelation["CmsSlot"] = Field(default=...)
 
 
 class CmsBlockEndpoint(AdminEndpoint[CmsBlock]):

{shopware_api_client-1.1.1 → shopware_api_client-1.1.5}/src/shopware_api_client/endpoints/admin/core/cms_page.py

@@ -1,15 +1,17 @@
+from pydantic import Field
+
 from shopware_api_client.base import AdminModel, AdminEndpoint
 from shopware_api_client.endpoints.relations import ForeignRelation, ManyRelation
 from shopware_api_client.models.cms_page import CmsPageBase
 
 
 class CmsPage(CmsPageBase, AdminModel["CmsPageEndpoint"]):
-    sections: ManyRelation["CmsSection"]
-    preview_media: ForeignRelation["Media"]
-    categories: ManyRelation["Category"]
-    landing_pages: ManyRelation["LandingPage"]
-    home_sales_channels: ManyRelation["SalesChannel"]
-    products: ManyRelation["Product"]
+    sections: ManyRelation["CmsSection"] = Field(default=...)
+    preview_media: ForeignRelation["Media"] = Field(default=...)
+    categories: ManyRelation["Category"] = Field(default=...)
+    landing_pages: ManyRelation["LandingPage"] = Field(default=...)
+    home_sales_channels: ManyRelation["SalesChannel"] = Field(default=...)
+    products: ManyRelation["Product"] = Field(default=...)
 
 
 class CmsPageEndpoint(AdminEndpoint[CmsPage]):