karrio-server-graph 2025.5__py3-none-any.whl

karrio/server/graph/tests/test_user_info.py

@@ -0,0 +1,71 @@
+from unittest.mock import ANY
+from karrio.server.graph.tests.base import GraphTestCase
+
+
+class TestUserUpdate(GraphTestCase):
+    def test_update_user_info(self):
+        response = self.query(
+            """
+            mutation update_user($data: UpdateUserInput!) {
+              update_user(input: $data) {
+                user {
+                  email
+                  full_name
+                  is_staff
+                  last_login
+                  date_joined
+                }
+              }
+            }
+            """,
+            operation_name="update_user",
+            variables=USER_UPDATE_DATA,
+        )
+        response_data = response.data
+
+        self.assertResponseNoErrors(response)
+        self.assertDictEqual(response_data, USER_UPDATE_RESPONSE)
+
+
+class TestTokenMutation(GraphTestCase):
+    def test_update_token(self):
+        current_token = self.token.key
+        response = self.query(
+            """
+            mutation mutate_token($data: TokenMutationInput!) {
+              mutate_token(input: $data) {
+                token {
+                  key
+                  created
+                }
+              }
+            }
+            """,
+            operation_name="mutate_token",
+            variables={
+                "data": {"refresh": True, "password": "test", "key": current_token}
+            },
+        )
+        response_data = response.data
+
+        self.assertResponseNoErrors(response)
+        self.assertFalse(
+            response_data["data"]["mutate_token"]["token"]["key"] == current_token
+        )
+
+
+USER_UPDATE_DATA = {"data": {"full_name": "Marco"}}
+
+USER_UPDATE_RESPONSE = {
+    "data": {
+        "update_user": {
+            "user": {
+                "date_joined": ANY,
+                "email": "admin@example.com",
+                "full_name": "Marco",
+                "is_staff": True,
+                "last_login": ANY,
+            }
+        }
+    }
+}

karrio/server/graph/urls.py

@@ -0,0 +1,10 @@
+"""
+karrio server graph module urls
+"""
+from django.urls import path, include
+
+
+app_name = "karrio.server.graph"
+urlpatterns = [
+    path("", include("karrio.server.graph.views")),
+]

karrio/server/graph/utils.py

@@ -0,0 +1,308 @@
+from karrio.server.core.utils import *
+import typing
+import base64
+import functools
+import strawberry
+import dataclasses
+from rest_framework import exceptions
+from django.utils.translation import gettext_lazy as _
+
+import karrio.lib as lib
+import karrio.server.core.utils as utils
+import karrio.server.core.models as core
+import karrio.server.orders.models as orders
+import karrio.server.manager.models as manager
+import karrio.server.providers.models as providers
+import karrio.server.core.permissions as permissions
+import karrio.server.core.serializers as serializers
+from karrio.server.core.logging import logger
+
+Cursor = str
+T = typing.TypeVar("T")
+GenericType = typing.TypeVar("GenericType")
+
+error_logger = utils.error_wrapper
+
+JSON: typing.Any = strawberry.scalar(
+    typing.NewType("JSON", object),
+    description="The `JSON` scalar type represents JSON values as specified by ECMA-404",
+)
+MANUAL_SHIPMENT_STATUSES = [
+    (_.name, _.name)
+    for _ in [
+        serializers.ShipmentStatus.in_transit,
+        serializers.ShipmentStatus.needs_attention,
+        serializers.ShipmentStatus.delivery_failed,
+        serializers.ShipmentStatus.delivered,
+    ]
+]
+
+CurrencyCodeEnum: typing.Any = strawberry.enum(  # type: ignore
+    lib.Enum("CurrencyCodeEnum", serializers.CURRENCIES)
+)
+CountryCodeEnum: typing.Any = strawberry.enum(  # type: ignore
+    lib.Enum("CountryCodeEnum", serializers.COUNTRIES)
+)
+DimensionUnitEnum: typing.Any = strawberry.enum(  # type: ignore
+    lib.Enum("DimensionUnitEnum", serializers.DIMENSION_UNIT)
+)
+WeightUnitEnum: typing.Any = strawberry.enum(  # type: ignore
+    lib.Enum("WeightUnitEnum", serializers.WEIGHT_UNIT)
+)
+CustomsContentTypeEnum: typing.Any = strawberry.enum(  # type: ignore
+    lib.Enum("CustomsContentTypeEnum", serializers.CUSTOMS_CONTENT_TYPE)
+)
+IncotermCodeEnum: typing.Any = strawberry.enum(  # type: ignore
+    lib.Enum("IncotermCodeEnum", serializers.INCOTERMS)
+)
+PaidByEnum: typing.Any = strawberry.enum(  # type: ignore
+    lib.Enum("PaidByEnum", serializers.PAYMENT_TYPES)
+)
+LabelTypeEnum: typing.Any = strawberry.enum(  # type: ignore
+    lib.Enum("LabelTypeEnum", serializers.LABEL_TYPES)
+)
+LabelTemplateTypeEnum: typing.Any = strawberry.enum(  # type: ignore
+    lib.Enum("LabelTemplateTypeEnum", serializers.LABEL_TEMPLATE_TYPES)
+)
+ShipmentStatusEnum: typing.Any = strawberry.enum(  # type: ignore
+    lib.Enum("ShipmentStatusEnum", serializers.SHIPMENT_STATUS)
+)
+ManualShipmentStatusEnum: typing.Any = strawberry.enum(  # type: ignore
+    lib.Enum("ManualShipmentStatusEnum", MANUAL_SHIPMENT_STATUSES)
+)
+TrackerStatusEnum: typing.Any = strawberry.enum(  # type: ignore
+    lib.Enum("TrackerStatusEnum", serializers.TRACKER_STATUS)
+)
+CarrierNameEnum: typing.Any = strawberry.enum(  # type: ignore
+    lib.Enum("CarrierNameEnum", serializers.CARRIERS)
+)
+MetafieldTypeEnum: typing.Any = strawberry.enum(  # type: ignore
+    lib.Enum("MetafieldTypeEnum", core.METAFIELD_TYPE)
+)
+
+
+class MetadataObjectType(lib.Enum):
+    carrier = providers.Carrier
+    commodity = manager.Commodity
+    shipment = manager.Shipment
+    tracker = manager.Tracking
+    order = orders.Order
+
+
+MetadataObjectTypeEnum: typing.Any = strawberry.enum(  # type: ignore
+    lib.StrEnum(
+        "MetadataObjectTypeEnum", [(c.name, c.name) for c in list(MetadataObjectType)]
+    )
+)
+
+
+def authentication_required(func):
+    @functools.wraps(func)
+    def wrapper(info, **kwargs):
+        user = getattr(info.context.request, 'user', None)
+
+        if user is None or user.is_anonymous:
+            raise exceptions.AuthenticationFailed(
+                _("You are not authenticated"), code="authentication_required"
+            )
+
+        if not user.is_verified():
+            raise exceptions.AuthenticationFailed(
+                _("Authentication Token not verified"), code="two_factor_required"
+            )
+
+        return func(info, **kwargs)
+
+    return wrapper
+
+
+def password_required(func):
+    @functools.wraps(func)
+    def wrapper(info, **kwargs):
+        password = kwargs.get("password")
+
+        if not info.context.request.user.check_password(password):
+            raise exceptions.ValidationError({"password": "Invalid password"})
+
+        return func(info, **kwargs)
+
+    return wrapper
+
+
+def authorization_required(keys: typing.List[str] = None):
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(info, **kwargs):
+            permissions.check_permissions(
+                context=info.context.request,
+                keys=keys or [],
+            )
+
+            return func(info, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+@strawberry.type
+class ErrorType:
+    field: str
+    messages: typing.List[str]
+
+    @staticmethod
+    def from_errors(errors):
+        return []
+
+
+@strawberry.input
+class BaseInput:
+    def pagination(self) -> typing.Dict[str, typing.Any]:
+        return {
+            k: v
+            for k, v in dataclass_to_dict(self).items()
+            if k in ["offset", "before", "after", "first", "last"]
+        }
+
+    def to_dict(self) -> typing.Dict[str, typing.Any]:
+        return dataclass_to_dict(self)
+
+
+@strawberry.type
+class BaseMutation:
+    errors: typing.Optional[typing.List[ErrorType]] = None
+
+
+@strawberry.type
+class UsageStatType:
+    date: typing.Optional[str] = None
+    label: typing.Optional[str] = None
+    count: typing.Optional[float] = None
+    amount: typing.Optional[float] = None
+    currency: typing.Optional[str] = None
+
+    @staticmethod
+    def parse(value: dict, label: str = None) -> "UsageStatType":
+        return UsageStatType(**{
+            **(dict(label=label) if label else {}),
+            **{k: v for k, v in value.items() if k in UsageStatType.__annotations__},
+            "amount": lib.to_decimal(value.get("amount")),
+        })
+
+
+@strawberry.input
+class UsageFilter(BaseInput):
+    date_after: typing.Optional[str] = strawberry.UNSET
+    date_before: typing.Optional[str] = strawberry.UNSET
+    omit: typing.Optional[typing.List[str]] = strawberry.UNSET
+    surcharge_id: typing.Optional[str] = strawberry.UNSET
+
+
+@dataclasses.dataclass
+@strawberry.type
+class Connection(typing.Generic[GenericType]):
+    """Represents a paginated relationship between two entities
+    This pattern is used when the relationship itself has attributes.
+    In a Facebook-based domain example, a friendship between two people
+    would be a connection that might have a `friendshipStartTime`
+    """
+
+    page_info: "PageInfo"
+    edges: typing.List["Edge[GenericType]"]
+
+
+@dataclasses.dataclass
+@strawberry.type
+class PageInfo:
+    """Pagination context to navigate objects with cursor-based pagination
+    Instead of classic offset pagination via `page` and `limit` parameters,
+    here we have a cursor of the last object and we fetch items starting from that one
+    Read more at:
+        - https://graphql.org/learn/pagination/#pagination-and-edges
+        - https://relay.dev/graphql/connections.htm
+    """
+
+    count: int
+    has_next_page: bool
+    has_previous_page: bool
+    start_cursor: typing.Optional[str]
+    end_cursor: typing.Optional[str]
+
+
+@dataclasses.dataclass
+@strawberry.type
+class Edge(typing.Generic[GenericType]):
+    """An edge may contain additional information of the relationship. This is the trivial case"""
+
+    node: GenericType
+    cursor: str
+
+
+@strawberry.input
+class Paginated(BaseInput):
+    offset: typing.Optional[int] = strawberry.UNSET
+    first: typing.Optional[int] = strawberry.UNSET
+
+
+def build_entity_cursor(entity: T):
+    """Adapt this method to build an *opaque* ID from an instance"""
+    entityid = f"{getattr(entity, 'id', id(entity))}".encode("utf-8")
+    return base64.b64encode(entityid).decode()
+
+
+def paginated_connection(
+    queryset,
+    first: int = 25,
+    offset: int = 0,
+) -> Connection[T]:
+    """A non-trivial implementation should efficiently fetch only
+    the necessary books after the offset.
+    For simplicity, here we build the list and then slice it accordingly
+    """
+
+    # Fetch the requested results plus one, just to calculate `has_next_page`
+    # fmt: off
+    results = queryset[offset:offset+first+1]
+    # fmt: on
+
+    edges: typing.List[typing.Any] = [
+        Edge(node=typing.cast(T, entity), cursor=build_entity_cursor(entity))
+        for entity in results
+    ]
+    return Connection(
+        page_info=PageInfo(
+            count=queryset.count(),
+            has_previous_page=False,
+            has_next_page=len(results) > first,
+            start_cursor=edges[0].cursor if edges else None,
+            end_cursor=edges[-2].cursor if len(edges) > 1 else None,
+        ),
+        edges=(edges[:-1] if len(edges) > first else edges),
+    )
+
+
+def is_unset(v: typing.Any) -> bool:
+    return isinstance(v, type(strawberry.UNSET)) or v == strawberry.UNSET
+
+
+def _dict_factory(items):
+    if isinstance(next(iter(items), None), tuple):
+        return dict(
+            [
+                (key, _dict_factory(value) if isinstance(value, list) else value)
+                for key, value in items
+                if not is_unset(value)
+            ]
+        )
+
+    return items
+
+
+def dataclass_to_dict(data):
+    return lib.to_dict(
+        dataclasses.asdict(
+            data,
+            dict_factory=_dict_factory,
+        ),
+        clear_empty=False,
+    )

karrio/server/graph/views.py

@@ -0,0 +1,91 @@
+"""
+karrio server graph module urls
+"""
+
+import pydoc
+import typing
+from django.urls import path
+from django.conf import settings
+from rest_framework import exceptions
+from django.views.decorators.csrf import csrf_exempt
+import graphql.error.graphql_error as graphql
+import strawberry.django.views as views
+import strawberry.types as types
+import strawberry.http as http
+
+import karrio.lib as lib
+import karrio.server.conf as conf
+import karrio.server.graph.schema as schema
+from karrio.server.core.logging import logger
+ACCESS_METHOD = getattr(
+    settings,
+    "SESSION_ACCESS_MIXIN",
+    "karrio.server.core.authentication.AccessMixin",
+)
+AccessMixin: typing.Any = pydoc.locate(ACCESS_METHOD)
+
+
+class GraphQLView(AccessMixin, views.GraphQLView):
+    def dispatch(self, request, *args, **kwargs):
+        should_render_graphiql = lib.failsafe(
+            lambda: self.should_render_graphiql(request)
+        )
+
+        if should_render_graphiql:
+            context = dict(APP_NAME=conf.settings.APP_NAME)
+
+            return self._render_graphiql(request, context=context)
+
+        return super().dispatch(request, *args, **kwargs)
+
+    def process_result(
+        self, request, result: types.ExecutionResult
+    ) -> http.GraphQLHTTPResponse:
+        data: http.GraphQLHTTPResponse = {"data": result.data}
+
+        if result.errors:
+            data["errors"] = [self.format_graphql_error(err) for err in result.errors]
+        if result.extensions:
+            data["extensions"] = result.extensions
+
+        return data
+
+    def format_graphql_error(self, error: graphql.GraphQLError):
+        formatted_error: dict = (
+            graphql.format_error(error)  # type: ignore
+            if isinstance(error, graphql.GraphQLError)
+            else {}
+        )
+
+        if isinstance(error.original_error, exceptions.APIException):
+            formatted_error["message"] = str(error.original_error.detail)
+            formatted_error["code"] = (
+                error.original_error.get_codes()
+                if hasattr(error.original_error, "get_codes")
+                else getattr(
+                    error.original_error,
+                    "code",
+                    getattr(error.original_error, "default_code", None),
+                )
+            )
+            formatted_error["status_code"] = error.original_error.status_code
+
+        if isinstance(error.original_error, exceptions.ValidationError):
+            formatted_error["message"] = str(error.original_error.default_detail)
+            formatted_error["validation"] = error.original_error.detail
+
+        return formatted_error
+
+
+urlpatterns = [
+    path(
+        "graphql/",
+        csrf_exempt(GraphQLView.as_view(schema=schema.schema)),
+        name="graphql",
+    ),
+    path(
+        "graphql",
+        csrf_exempt(GraphQLView.as_view(schema=schema.schema)),
+        name="graphql-api",
+    ),
+]

karrio/server/settings/graph.py

@@ -0,0 +1,7 @@
+# type: ignore
+from karrio.server.settings.base import *
+
+
+INSTALLED_APPS += [
+    "strawberry.django",
+]

karrio_server_graph-2025.5.dist-info/METADATA

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: karrio_server_graph
+Version: 2025.5
+Summary: Multi-carrier shipping API Graph module
+Author-email: karrio <hello@karrio.io>
+License-Expression: LGPL-3.0
+Project-URL: Homepage, https://github.com/karrioapi/karrio
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: karrio_server_core
+Requires-Dist: django-filter
+Requires-Dist: strawberry-graphql
+
+# karrio.server.graph
+
+This package is a module of the [karrio](https://pypi.org/project/karrio.server) universal shipping API.
+
+## Requirements
+
+`Python 3.11+`
+
+## Installation
+
+```bash
+pip install karrio.server.graph
+```
+
+Check the [karrio docs](https://docs.karrio.io) to get started.

karrio_server_graph-2025.5.dist-info/RECORD

@@ -0,0 +1,39 @@
+karrio/server/graph/__init__.py,sha256=iOEMwnlORWezdO8-2vxBIPSR37D7JGjluZ8f55vzxls,81
+karrio/server/graph/admin.py,sha256=suMo4x8I3JBxAFBVIdE-5qnqZ6JAZV0FESABHOSc-vg,63
+karrio/server/graph/apps.py,sha256=grL5ySDnW2amzj0nTXFm-WCoTWViVYvKqGlsi4k5epI,99
+karrio/server/graph/forms.py,sha256=7ow-WZ3OFUmnakj28nabWJflU1atAb86roJiok1NQ7A,1949
+karrio/server/graph/models.py,sha256=CEnE4AsVyjBufyK6ebWmUH3s8DwA0HvZg0fUoZb5Pn4,1321
+karrio/server/graph/schema.py,sha256=uENWASUR0r0RZGr8j5bp_xlBOskxqhW7Z-PYCkC-uzE,1226
+karrio/server/graph/serializers.py,sha256=qhnr8sbv09uY1GBChR2fTZTrPrElu8YtIv86JfFL0oc,13744
+karrio/server/graph/urls.py,sha256=HKo0gkx5TgoWDV0ap2QCtueNTmaAqvX6qVDe3c2UT1E,183
+karrio/server/graph/utils.py,sha256=W68fmaEGp8giS3PFBPekjzd5aIPrbw7XOnKBYRBL0bs,9302
+karrio/server/graph/views.py,sha256=H9GJAgd8y0yV9Z1qpxhBo5o7dfCZgegzebHi100M_E8,2882
+karrio/server/graph/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+karrio/server/graph/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+karrio/server/graph/management/commands/export_schema.py,sha256=WMwiDISpTwtA6MRqSxKjX9LOa3caWEHA_OKRxPIgcsQ,294
+karrio/server/graph/migrations/0001_initial.py,sha256=oeaS5JSkQP6w9ulYar3mdn695ybkog-1QoyKUIW1SCg,1609
+karrio/server/graph/migrations/0002_auto_20210512_1353.py,sha256=TnUwR9EP0qp3gJ38f9w0PYawK2VheDtqXEgyRhYZS2M,538
+karrio/server/graph/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+karrio/server/graph/schemas/__init__.py,sha256=Kn-I1j3HP3jwZccpz6FL9r1k6b3UEAMVh2kFPCKNS0w,80
+karrio/server/graph/schemas/base/__init__.py,sha256=nnOfynQW842qOA0qD6bYz8GSHQCQeBW36vbq0sqRkJs,15121
+karrio/server/graph/schemas/base/inputs.py,sha256=p6_u4sG1cbd18CpPjkyG3CD4cbvf4gBa3De4RDgCZ80,21419
+karrio/server/graph/schemas/base/mutations.py,sha256=6ljP3_2UpUHpYIl06I7n-owQjUp2TT5jDgZ_fEzvB6o,35043
+karrio/server/graph/schemas/base/types.py,sha256=FBayGYWlqcHK0tm43xFA6ZkUFlr1htM7-TutRKPmTkc,47613
+karrio/server/graph/templates/graphql/graphiql.html,sha256=MQjQbBqoRE0QLsOUck8SaXo6B2oJO8dT6YZzUqbDan0,3786
+karrio/server/graph/templates/karrio/email_change_email.html,sha256=gr55F97GYzY27TVKGl49037yd60eSYD0b0GXRlyoco4,552
+karrio/server/graph/templates/karrio/email_change_email.txt,sha256=NXXuzLR63hn2F1fVAjzmuguptuuTvujwqI7YLSrQoio,431
+karrio/server/graph/templates/karrio/password_reset_email.html,sha256=dttqYVL73cQNuTFsVdn2GV4Ckee8PTY8oEF53GbDRcg,553
+karrio/server/graph/tests/__init__.py,sha256=dPzsYY5hoO5gmY6fhL8tiz7Bfst8RB3JzsBVHZazHRE,338
+karrio/server/graph/tests/base.py,sha256=dzLiva3eTAsbBM5Ga8SI2fxSanBQgAqswS0YVdtTfEg,5122
+karrio/server/graph/tests/test_carrier_connections.py,sha256=qZ1OL8CgZrHuluKJd7cjFXaRZ0VpogN5Srjk2EApLWU,6892
+karrio/server/graph/tests/test_metafield.py,sha256=K7Oon0CLEm_MUMbmcu0t2iAZvFN8Wl7Kp4QAWeUXo_Y,12783
+karrio/server/graph/tests/test_partial_shipments.py,sha256=dPIdIq4wiyovOaIIzbIX69eZnBqCA4ZvBSiGKYADM2g,19031
+karrio/server/graph/tests/test_rate_sheets.py,sha256=cUzPV8dXQFPFh1r7W8bY6Lou3fjh8f9VGpyZrfbMXec,10300
+karrio/server/graph/tests/test_registration.py,sha256=0vCTqlsLc0cl2m78umgfm7grnDgTI_NZJWNUrRUlQBY,7107
+karrio/server/graph/tests/test_templates.py,sha256=WVU6vcfr6tEk917uSn1dECU8bkQtgD7FNuE-GJuFido,21626
+karrio/server/graph/tests/test_user_info.py,sha256=K91BL7SgxLWflCZriSVI8Vt5M5RIqmSCHKrgN2w8GmM,1928
+karrio/server/settings/graph.py,sha256=cz2yQHbp3xCfyFKuUkPEFfkI2fFVggExIY49wGz7mt0,106
+karrio_server_graph-2025.5.dist-info/METADATA,sha256=iD1WSW3xUAPEL2uzrVdZqsMUUWhM93oRsW3dzSoNYL8,738
+karrio_server_graph-2025.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+karrio_server_graph-2025.5.dist-info/top_level.txt,sha256=D1D7x8R3cTfjF_15mfiO7wCQ5QMtuM4x8GaPr7z5i78,12
+karrio_server_graph-2025.5.dist-info/RECORD,,

karrio_server_graph-2025.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

karrio_server_graph-2025.5.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+dist
+karrio