spinta 0.2.dev12__tar.gz → 0.2.dev13__tar.gz

{spinta-0.2.dev12 → spinta-0.2.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spinta
-Version: 0.2.dev12
+Version: 0.2.dev13
 Summary: A platform for describing, extracting, transforming, loading and serving open data.
 License: MIT
 License-File: LICENSE

{spinta-0.2.dev12 → spinta-0.2.dev13}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "spinta"
-version = "0.2dev12"
+version = "0.2dev13"
 description = "A platform for describing, extracting, transforming, loading and serving open data."
 authors = ["Mantas Zimnickas <sirexas@gmail.com>"]
 license = "MIT"

spinta-0.2.dev13/spinta/__init__.py

@@ -0,0 +1,3 @@
+import importlib.metadata
+
+__version__ = importlib.metadata.version(__name__)

{spinta-0.2.dev12 → spinta-0.2.dev13}/spinta/api/__init__.py

@@ -422,7 +422,7 @@ async def error(request, exc):
 
 async def srid_check(request: Request):
     from shapely.geometry import Point
-    from spinta.backends.postgresql.types.geometry.helpers import get_osm_link
+    from spinta.types.geometry.helpers import get_osm_link
 
     srid = request.path_params["srid"]
     x = request.path_params["x"]

{spinta-0.2.dev12 → spinta-0.2.dev13}/spinta/asgi.py

@@ -1,20 +1,13 @@
-import logging
-
 from spinta.api import init
 from spinta.core.context import create_context
 from spinta import commands
 
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(levelname)s: %(message)s",
-)
-
 context = create_context("asgi")
 
 rc = context.get("rc")
 config = context.get("config")
 commands.load(context, config)
+
 commands.check(context, config)
 
 store = context.get("store")

{spinta-0.2.dev12 → spinta-0.2.dev13}/spinta/auth.py

@@ -12,6 +12,7 @@ import time
 import uuid
 from collections import defaultdict
 from functools import cached_property
+from itertools import chain
 from threading import Lock
 from typing import Set, Any, TypedDict, Literal
 from typing import Type
@@ -26,7 +27,7 @@ from authlib.oauth2 import OAuth2Error
 from authlib.oauth2 import OAuth2Request
 from authlib.oauth2 import rfc6749
 from authlib.oauth2 import rfc6750
-from authlib.oauth2.rfc6749 import grants, OAuth2Payload, scope_to_list, list_to_scope
+from authlib.oauth2.rfc6749 import grants, OAuth2Payload, list_to_scope
 from authlib.oauth2.rfc6749.errors import InvalidClientError
 from authlib.oauth2.rfc6750.errors import InsufficientScopeError
 from authlib.oauth2.rfc6749.util import scope_to_list
@@ -40,11 +41,12 @@ from starlette.datastructures import FormData, QueryParams, Headers
 from starlette.exceptions import HTTPException
 from starlette.responses import JSONResponse
 
+from spinta import commands
 from spinta.components import Config
 from spinta.components import Context, Namespace, Model, Property
 from spinta.components import ScopeFormatterFunc
 from spinta.core.enums import Access, Action
-from spinta.exceptions import AuthorizedClientsOnly
+from spinta.exceptions import AuthorizedClientsOnly, NoScopesForNamespaces, InvalidExtraScopes
 from spinta.exceptions import BasicAuthRequired
 from spinta.exceptions import (
     InvalidToken,
@@ -297,6 +299,7 @@ class Client(rfc6749.ClientMixin):
     secret_hash: str
     scopes: Set[str]
     backends: dict[str, dict[str, Any]]
+    contract_scopes: dict[str, list[str]]
 
     def __init__(
         self,
@@ -306,12 +309,14 @@ class Client(rfc6749.ClientMixin):
         secret_hash: str,
         scopes: list[str],
         backends: dict[str, dict[str, Any]],
+        contract_scopes: dict[str, list[str]],
     ) -> None:
         self.id = id_
         self.name = name_
         self.secret_hash = secret_hash
         self.scopes = set(scopes)
         self.backends = backends
+        self.contract_scopes = contract_scopes
 
         # Auth method used for token endpoint.
         # More info: token_endpoint_auth_method https://datatracker.ietf.org/doc/html/rfc7591#autoid-5
@@ -360,6 +365,9 @@ class Client(rfc6749.ClientMixin):
         else:
             return True
 
+    def get_all_contract_scopes(self) -> set[str]:
+        return set(chain.from_iterable(self.contract_scopes.values()))
+
 
 def decode_unverified_header(token: str) -> dict[str, Any]:
     try:
@@ -399,33 +407,34 @@ class Token(rfc6749.TokenMixin):
         required_scopes = scope_to_list(scope)
         return not self._validator.scope_insufficient(self.get_scope(), required_scopes)
 
-    def check_scope(self, scope: SCOPE_TYPE):
+    def check_scope(self, scope: SCOPE_TYPE) -> bool:
         token_scopes = set(scope_to_list(self._token.get("scope", "")))
         if any(token_scope for token_scope in token_scopes if token_scope.startswith(DEPRECATED_SCOPE_PREFIX)):
             log.warning(
                 "Deprecation warning: using 'spinta_*' scopes is deprecated and will be removed in a future version."
             )
 
-        if not self.valid_scope(scope):
-            client_id = self._token["aud"]
+        if self.valid_scope(scope):
+            return True
 
-            operator = "OR"
-            if isinstance(scope, str):
-                operator = "AND"
-                scope = [scope]
-            missing_scopes = ", ".join(
-                sorted([single_scope for single_scope in scope if not single_scope.startswith(DEPRECATED_SCOPE_PREFIX)])
-            )
+        # Scope is not valid. Raise an exception
+        client_id = self._token["aud"]
 
-            # FIXME: this should be wrapped into UserError.
-            if operator == "AND":
-                log.error(f"client {client_id!r} is missing required scopes: %s", missing_scopes)
-                raise InsufficientScopeError(description=f"Missing scopes: {missing_scopes}")
-            elif operator == "OR":
-                log.error(f"client {client_id!r} is missing one of required scopes: %s", missing_scopes)
-                raise InsufficientScopeError(description=f"Missing one of scopes: {missing_scopes}")
-            else:
-                raise Exception(f"Unknown operator {operator}.")
+        require_all_scopes = isinstance(scope, str)
+        scope_list = [scope] if require_all_scopes else scope
+
+        missing_scopes = ", ".join(
+            sorted(single_scope for single_scope in scope_list if not single_scope.startswith(DEPRECATED_SCOPE_PREFIX))
+        )
+
+        if require_all_scopes:
+            message = f"Missing required scopes: {missing_scopes}"
+            log.error(f"client {client_id!r} is missing required scopes: %s", missing_scopes)
+        else:
+            message = f"Missing one of required scopes: {missing_scopes}"
+            log.error(f"client {client_id!r} is missing one of required scopes: %s", missing_scopes)
+
+        raise InsufficientScopeError(description=message)
 
     # No longer mandatory, but will keep it, since it is used in other places.
     def get_client_id(self) -> str:
@@ -458,12 +467,82 @@ class Token(rfc6749.TokenMixin):
     def is_expired(self) -> bool:
         return time.time() > self._token["exp"]
 
+    @staticmethod
+    def _collect_available_namespaces(context: Context) -> set[str]:
+        """Collects all scopes that can be used to get data from currently loaded manifest"""
+
+        manifest = context.get("store").manifest
+        model_namespaces = chain.from_iterable(
+            model.get_namespaces()
+            for model in commands.get_models(context, manifest).values()
+            if not model.name.startswith("_")
+        )
+
+        return set(model_namespaces)
+
+    @staticmethod
+    def _get_scope_namespace(single_scope: str, scope_prefixes: list[str]) -> str:
+        """Removes spinta prefixes and action suffixes, leaving only namespace part of scope"""
+        for prefix in scope_prefixes:
+            if single_scope.startswith(prefix):
+                single_scope = single_scope.removeprefix(prefix)
+
+        for action in Action.scope_action_values():
+            if single_scope.endswith(action):
+                single_scope = single_scope.removesuffix(action)
+
+        return single_scope
+
+    def _get_namespace_scope_map(self, scope_prefixes: list[str]) -> dict[str, set[str]]:
+        """
+        Splits JWT scope into separate scopes and build a mapping of namespaces to their corresponding scopes
+        """
+        scope_dict = defaultdict(set)
+        for scope in scope_to_list(self.get_scope()):
+            if namespace := self._get_scope_namespace(scope, scope_prefixes):
+                scope_dict[namespace].add(scope)
+
+        return dict(scope_dict)
+
+    def _get_scopes_from_model_namespaces(self, model_namespaces: set[str], scope_prefixes: list[str]) -> set[str]:
+        """Returns only JWT scopes that match any namespaces from manifest"""
+        scope_namespace_map = self._get_namespace_scope_map(scope_prefixes)
+
+        return {
+            scope
+            for namespace, scopes in scope_namespace_map.items()
+            if namespace in model_namespaces
+            for scope in scopes
+        }
+
+    def check_contract_scopes(self, context: Context) -> None:
+        """
+        Checks if there are no extra JWT scopes from manifest namespaces comparing to contract scopes saved
+        in client's file.
+        """
+
+        if not (model_namespaces := self._collect_available_namespaces(context)):
+            raise NoScopesForNamespaces(namespaces=[])
+
+        config = context.get("config")
+        client = query_client(get_clients_path(config), self.get_client_id())
+
+        contract_scopes = client.get_all_contract_scopes()
+        filtered_jwt_scopes = self._get_scopes_from_model_namespaces(
+            model_namespaces, [config.scope_prefix, config.scope_prefix_udts]
+        )
+
+        if not filtered_jwt_scopes:
+            raise NoScopesForNamespaces(namespaces=", ".join(sorted(model_namespaces)))
+        elif not contract_scopes.issuperset(filtered_jwt_scopes):
+            raise InvalidExtraScopes(extra_scopes=", ".join(sorted(filtered_jwt_scopes - contract_scopes)))
+
 
 class AdminToken(rfc6749.TokenMixin):
     def valid_scope(self, scope: SCOPE_TYPE, **kwargs) -> bool:
         return True
 
-    def check_scope(self, scope: SCOPE_TYPE, **kwargs):
+    def check_scope(self, scope: SCOPE_TYPE, **kwargs) -> bool:
         pass
 
     def get_sub(self) -> str:  # User.
@@ -478,6 +557,9 @@ class AdminToken(rfc6749.TokenMixin):
     def get_client_id(self) -> str:
         return self.get_aud()
 
+    def check_contract_scopes(self, context: Context) -> None:
+        pass
+
 
 @dataclasses.dataclass
 class StarletteOAuth2Data:
@@ -556,6 +638,7 @@ def get_auth_token(context: Context) -> Token:
         token = resource_protector.validate_request(scope, request)
     except JoseError as e:
         raise HTTPException(status_code=400, detail=e.error)
+
     return token
 
 
@@ -687,14 +770,14 @@ def get_client_file_path(path: pathlib.Path, client: str) -> pathlib.Path:
     return client_file
 
 
-def check_scope(context: Context, scope: Union[Scopes, str]):
+def check_scope(context: Context, scope: Union[Scopes, str]) -> bool:
     config = context.get("config")
     token = context.get("auth.token")
 
     if isinstance(scope, Scopes):
         scope = scope.value
 
-    token.check_scope([f"{config.scope_prefix}{scope}", f"{config.scope_prefix_udts}:{scope}"])
+    return token.check_scope([f"{config.scope_prefix}{scope}", f"{config.scope_prefix_udts}:{scope}"])
 
 
 def has_scope(context: Context, scope: Scopes | str, raise_error: bool = True) -> bool:
@@ -819,9 +902,15 @@ def authorized(
     ]
     # Check if client has at least one of required scopes.
     if throw:
-        token.check_scope(scopes)
+        is_token_valid = token.check_scope(scopes)
     else:
-        return token.valid_scope(scopes)
+        is_token_valid = token.valid_scope(scopes)
+
+    # Contract scopes are only checked for non-open nodes and when check_contract_scopes is enabled
+    if config.check_contract_scopes and node.access < Access.open:
+        token.check_contract_scopes(context)
+
+    return is_token_valid
 
 
 def auth_server_keys_exists(path: pathlib.Path):
@@ -905,6 +994,7 @@ def create_client_file(
     secret: str | None = None,
     scopes: List[str] | None = None,
     backends: dict[str, dict[str, str]] | None = None,
+    contract_scopes: dict[str, list[str]] | None = None,
     *,
     add_secret: bool = False,
 ) -> tuple[pathlib.Path, dict]:
@@ -937,6 +1027,7 @@ def create_client_file(
         "client_secret_hash": secret_hash,
         "scopes": scopes or [],
         "backends": backends or {},
+        "contract_scopes": contract_scopes or {},
     }
     keymap[name] = client_id
 
@@ -989,6 +1080,7 @@ def update_client_file(
     secret: str | None,
     scopes: list | None,
     backends: dict[str, dict[str, str]] | None,
+    contract_scopes: dict[str, list[str]] | None = None,
 ) -> dict:
     if client_exists(path, client_id):
         config = context.get("config")
@@ -1000,6 +1092,7 @@ def update_client_file(
         new_secret_hash = passwords.crypt(secret) if secret else client.secret_hash
         new_scopes = scopes if scopes is not None else client.scopes
         new_backends = backends if backends is not None else client.backends
+        new_contract_scopes = contract_scopes if contract_scopes is not None else client.contract_scopes
 
         client_path = get_client_file_path(path, client_id)
         keymap = _load_keymap_data(keymap_path)
@@ -1013,6 +1106,7 @@ def update_client_file(
             "client_secret_hash": new_secret_hash,
             "scopes": list(new_scopes),
             "backends": new_backends,
+            "contract_scopes": new_contract_scopes,
         }
 
         yml.dump(new_data, client_path)
@@ -1173,6 +1267,7 @@ def query_client(path: pathlib.Path, client: str, is_name: bool = False) -> Clie
         name_=client_name,
         secret_hash=data["client_secret_hash"],
         scopes=data["scopes"],
-        backends=data["backends"] if data.get("backends") else {},
+        backends=data.get("backends", {}),
+        contract_scopes=data.get("contract_scopes", {}),
     )
     return client

{spinta-0.2.dev12 → spinta-0.2.dev13}/spinta/backends/mongo/ufuncs/ufuncs.py

@@ -483,6 +483,11 @@ def sort(env, field):
     return env.call("asc", prop.dtype)
 
 
+@ufunc.resolver(MongoQueryBuilder, DataType)
+def sort(env: MongoQueryBuilder, dtype: DataType) -> Any:
+    return env.call("asc", dtype)
+
+
 @ufunc.resolver(MongoQueryBuilder, Positive)
 def sort(env, sign):
     return env.call("asc", sign.arg)

{spinta-0.2.dev12 → spinta-0.2.dev13}/spinta/backends/postgresql/types/geometry/encode.py

@@ -7,8 +7,8 @@ from geoalchemy2.shape import to_shape
 
 
 from spinta import commands
-from spinta.backends.postgresql.types.geometry.helpers import get_display_value
-from spinta.backends.postgresql.types.geometry.helpers import get_osm_link
+from spinta.types.geometry.helpers import get_display_value
+from spinta.types.geometry.helpers import get_osm_link
 from spinta.formats.components import Format
 from spinta.core.enums import Action
 from spinta.components import Context

{spinta-0.2.dev12 → spinta-0.2.dev13}/spinta/backends/postgresql/ufuncs/query/ufuncs.py

@@ -7,6 +7,7 @@ from typing import Union, Any
 import geoalchemy2.functions
 import sqlalchemy as sa
 from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.sql.elements import UnaryExpression
 
 from spinta import exceptions, commands
 from spinta.auth import authorized
@@ -1138,6 +1139,11 @@ def sort(env, dtype):
     return env.call("asc", dtype)
 
 
+@ufunc.resolver(PgQueryBuilder, NestedProperty)
+def sort(env: PgQueryBuilder, nested: NestedProperty) -> UnaryExpression:
+    return env.call("asc", nested.right)
+
+
 @ufunc.resolver(PgQueryBuilder, Negative_)
 def sort(env, field):
     prop = env.resolve_property(field)

{spinta-0.2.dev12 → spinta-0.2.dev13}/spinta/cli/main.py

@@ -77,15 +77,17 @@ def main(
     ),
     env_file: Optional[pathlib.Path] = Option(None, "--env-file", help=("Load configuration from a given .env file.")),
     version: bool = Option(False, help="Show version number."),
+    tb: Optional[str] = Option("pretty", "--tb", help=("Exception style: pretty, native.")),
+    # Deprecated. Use env file instead
     log_file: Optional[pathlib.Path] = Option(
         None, "--log-file", help=("Write log messages to a specified file, if not given, writes logs to STDERR.")
     ),
+    # Deprecated. Use env file instead
     log_level: Optional[str] = Option(
-        "warning",
+        None,
         "--log-level",
         help=("Log level. Possible levels: fatal, error, warning, info, debug. Default: warning."),
     ),
-    tb: Optional[str] = Option("pretty", "--tb", help=("Exception style: pretty, native.")),
 ):
     if tb == "pretty":
         app.pretty_exceptions_enable = True
@@ -94,15 +96,18 @@ def main(
     else:
         raise ValueError("Unknown value {tb!r} for --tb option. Possible values are: pretty, native.")
 
-    logging.basicConfig(
-        level=logging.getLevelName(log_level.upper()),
-        format="%(asctime)s %(levelname)s: %(message)s",
-        filename=log_file,
-    )
+    ctx.obj = ctx.obj or create_context("cli", args=option, envfile=env_file)
 
-    log.debug("log file set to: %s", log_file or "STDERR")
-    log.debug("log level set to: %s", log_level)
+    if log_file:
+        log.warning(
+            "Deprecation warning: log_file option is deprecated and will be removed in a future version. "
+            "Set file_log_path via env file instead."
+        )
+    if log_level:
+        log.warning(
+            "Deprecation warning:log_level option is deprecated and will be removed in a future version. "
+            "Set log_level and file_log_level via env file instead."
+        )
 
-    ctx.obj = ctx.obj or create_context("cli", args=option, envfile=env_file)
     if version:
         echo(spinta.__version__)

{spinta-0.2.dev12 → spinta-0.2.dev13}/spinta/cli/manifest.py

@@ -154,9 +154,9 @@ def _read_and_return_manifest(
     rename_duplicates: bool = False,
     verbose: bool = True,
     check_config: bool = True,
-    load_backends: bool = True,
+    ensure_backends: bool = True,
 ) -> Iterator[ManifestRow]:
-    context = configure_context(context, manifests, load_backends=load_backends)
+    context = configure_context(context, manifests, ensure_backends=ensure_backends)
     store = load_manifest(
         context,
         rename_duplicates=rename_duplicates,

{spinta-0.2.dev12 → spinta-0.2.dev13}/spinta/components.py

@@ -732,6 +732,19 @@ class Model(MetaData):
     def get_given_properties(self):
         return {prop_name: prop for prop_name, prop in self.properties.items() if not prop_name.startswith("_")}
 
+    def get_namespaces(self, include_self: bool = True) -> set[str]:
+        namespaces = []
+        if include_self:
+            namespaces.append(self.name)
+
+        if self.ns:
+            namespaces.append(self.ns.name)
+            namespaces.extend(
+                [parent_namespace.name for parent_namespace in self.ns.parents() if parent_namespace.name]
+            )
+
+        return set(namespaces)
+
 
 class PropertyGiven:
     access: str | None = None
@@ -1080,6 +1093,7 @@ class Config:
     scope_formatter: ScopeFormatterFunc
     scope_max_length: int
     scope_log: bool
+    check_contract_scopes: bool
     default_auth_client: str
     http_basic_auth: bool
     token_validation_key: dict | None = None
@@ -1113,6 +1127,10 @@ class Config:
     # Cache-Control header
     cache_control: str = ""
 
+    log_level: str
+    file_log_level: str
+    file_log_path: pathlib.Path
+
     def __init__(self):
         self.commands = _CommandsConfig()
         self.components = {}

{spinta-0.2.dev12 → spinta-0.2.dev13}/spinta/config.py

@@ -266,8 +266,8 @@ CONFIG = {
     "max_file_size": 100,
     # Used to determine max amount of errors can be thrown while writing, before canceling writing stream
     "max_error_count_on_insert": 100,
-    # Enables setting backends by default, disabled when Spinta used as library and does not contain configuration of backends
-    "load_backends": True,
+    # Ensures setting backends by default, disabled when Spinta used as library and does not contain configuration of backends
+    "ensure_backends": True,
     # Response Cache-Control header.
     "cache_control_header": "public, max-age=60, must-revalidate",
     "environments": {

{spinta-0.2.dev12 → spinta-0.2.dev13}/spinta/core/config.py

@@ -572,7 +572,7 @@ def configure_rc(
     resources: List[ResourceTuple] = None,
     dataset: str = None,
     manifest_type: str = "inline",
-    load_backends=True,
+    ensure_backends=True,
 ) -> RawConfig:
     config: Dict[str, Any] = {}
 
@@ -658,7 +658,7 @@ def configure_rc(
         if check_names is not None:
             config["check.names"] = check_names
 
-    config["load_backends"] = load_backends
+    config["ensure_backends"] = ensure_backends
 
     if config:
         rc = rc.fork(config)

{spinta-0.2.dev12 → spinta-0.2.dev13}/spinta/core/enums.py

@@ -127,6 +127,12 @@ class Action(enum.Enum):
     def values(cls):
         return list(cls._value2member_map_.keys())
 
+    @classmethod
+    def scope_action_values(cls) -> list[str]:
+        old_prefix_actions = list(map(lambda action: "_" + action, cls.values()))
+        new_prefix_actions = list(map(lambda action: "/:" + action, cls.values()))
+        return old_prefix_actions + new_prefix_actions
+
 
 class Mode(enum.Enum):
     # Internal mode always use internal backend set on manifest, namespace or

spinta-0.2.dev13/spinta/datasets/backends/sql/backends/oracle/helpers.py

@@ -0,0 +1,88 @@
+from typing import Any, Optional, Callable
+from sqlalchemy.sql.sqltypes import LargeBinary
+from sqlalchemy.types import UserDefinedType
+from sqlalchemy.dialects.oracle import base
+from sqlalchemy.sql.elements import ColumnElement
+from sqlalchemy import Column
+import sqlalchemy as sa
+
+
+class LONGRAW(LargeBinary):
+    __visit_name__ = "LONGRAW"
+
+
+class SDO_GEOMETRY(UserDefinedType):
+    cache_ok = True
+    __visit_name__ = "SDO_GEOMETRY"
+
+    def __init__(self, geometry_type: Optional[str] = None, srid: Optional[int] = None):
+        self.geometry_type = geometry_type
+        self.srid = srid
+
+    def get_col_spec(self, **kw: Any) -> str:
+        return "SDO_GEOMETRY"
+
+    def column_expression(self, col: Column) -> ColumnElement:
+        wkt_expr = sa.func.SDO_UTIL.TO_WKTGEOMETRY(col)
+        return sa.func.NVL(wkt_expr, None)
+
+    def result_processor(self, dialect: Any, coltype: Any) -> Optional[Callable]:
+        def process(value: Optional[Any]) -> Optional[Any]:
+            if value is None:
+                return None
+
+            # Handle CLOB/LOB objects from cx_Oracle/python-oracledb
+            # LOB objects have a .read() method to extract the string content
+            if hasattr(value, "read"):
+                try:
+                    value = value.read()
+                except Exception as e:
+                    import warnings
+
+                    warnings.warn(f"Failed to read CLOB/LOB for SDO_GEOMETRY: {e}")
+                    return None
+
+            if isinstance(value, str):
+                try:
+                    from shapely import from_wkt
+
+                    return from_wkt(value)
+                except Exception as e:
+                    import warnings
+
+                    warnings.warn(f"Failed to parse WKT geometry: {e}")
+                    return None
+
+            # Unexpected type - log warning and return None
+            import warnings
+
+            warnings.warn(f"Expected WKT string or LOB for SDO_GEOMETRY but got {type(value).__name__}")
+            return None
+
+        return process
+
+
+def flip_geometry_oracle(column: Column) -> ColumnElement:
+    return sa.func.SDO_UTIL.REVERSE_LINESTRING(column)
+
+
+if "LONG RAW" not in base.ischema_names:
+    base.ischema_names["LONG RAW"] = LONGRAW
+
+if not hasattr(base.OracleTypeCompiler, "visit_LONGRAW"):
+
+    def visit_LONGRAW(self, type_: LONGRAW, **kw: Any) -> str:
+        return "LONG RAW"
+
+    base.OracleTypeCompiler.visit_LONGRAW = visit_LONGRAW
+
+
+if "SDO_GEOMETRY" not in base.ischema_names:
+    base.ischema_names["SDO_GEOMETRY"] = SDO_GEOMETRY
+
+if not hasattr(base.OracleTypeCompiler, "visit_SDO_GEOMETRY"):
+
+    def visit_SDO_GEOMETRY(self, type_: SDO_GEOMETRY, **kw: Any) -> str:
+        return "SDO_GEOMETRY"
+
+    base.OracleTypeCompiler.visit_SDO_GEOMETRY = visit_SDO_GEOMETRY

spinta-0.2.dev13/spinta/datasets/backends/sql/backends/oracle/types/geometry/encode.py

@@ -0,0 +1,40 @@
+from typing import Any, Dict
+from shapely.geometry.base import BaseGeometry
+
+from spinta import commands
+from spinta.components import Context
+from spinta.core.enums import Action
+from spinta.formats.components import Format
+from spinta.formats.html.components import Cell, Html
+from spinta.types.geometry.components import Geometry
+from spinta.types.geometry.helpers import get_display_value, get_osm_link
+
+
+@commands.prepare_dtype_for_response.register(Context, Format, Geometry, BaseGeometry)
+def prepare_dtype_for_response(
+    context: Context,
+    fmt: Format,
+    dtype: Geometry,
+    value: BaseGeometry,
+    *,
+    data: Dict[str, Any],
+    action: Action,
+    select: dict = None,
+):
+    return value.wkt
+
+
+@commands.prepare_dtype_for_response.register(Context, Html, Geometry, BaseGeometry)
+def prepare_dtype_for_response(
+    context: Context,
+    fmt: Html,
+    dtype: Geometry,
+    value: BaseGeometry,
+    *,
+    data: Dict[str, Any],
+    action: Action,
+    select: dict = None,
+):
+    display_value = get_display_value(value)
+    osm_link = get_osm_link(value, dtype)
+    return Cell(display_value, link=osm_link)