oarepo-runtime 1.10.3__py3-none-any.whl → 2.0.0.dev3__py3-none-any.whl

oarepo_runtime/cli/permissions/list.py

@@ -1,239 +0,0 @@
-from typing import get_type_hints
-
-import click
-
-from oarepo_runtime.info.permissions.debug import add_debugging
-
-from .base import permissions
-
-
-@permissions.command(name="list")
-@click.option("--workflow", "-w", help="Workflow name")
-@click.option("--community", "-c", help="Community name")
-@click.option("--service", "-s", help="Service name")
-def list_permissions(workflow, community, service):
-    """List all permissions for a given workflow, community or service."""
-    # intentionally import here to enable oarepo-runtime to be used
-    # without oarepo-workflows and oarepo-communities
-    from invenio_communities.communities.records.api import Community
-    from invenio_communities.communities.records.models import CommunityMetadata
-    from oarepo_workflows.proxies import current_oarepo_workflows
-
-    if workflow:
-        wf = current_oarepo_workflows.record_workflows[workflow]
-        permission_policy = wf.permission_policy_cls
-    elif community:
-        community_db = CommunityMetadata.query.filter_by(slug=community).one()
-        community_obj = Community(community_db.data, model=community_db)
-        workflow = community_obj["custom_fields"].get("workflow", "default")
-        wf = current_oarepo_workflows.record_workflows[workflow]
-        permission_policy = wf.permission_policy_cls
-    elif service:
-        from invenio_records_resources.proxies import current_service_registry
-
-        swc = current_service_registry.get(service)
-        permission_policy = swc.config.permission_policy_cls
-    else:
-        raise click.UsageError(
-            "You must specify either --workflow, --community or --service."
-        )
-
-    add_debugging()
-
-    p = permission_policy("read")
-
-    for action_name in dir(permission_policy):
-        if not action_name.startswith("can_"):
-            continue
-        action_permission_generators = getattr(p, action_name)
-        debugs = []
-        for x in action_permission_generators:
-            debugs.append(x.to_debug_dict())
-
-        print("")
-        print(f"## {action_name}")
-        print(get_permission_documentation(permission_policy, action_name))
-        for perm in debugs:
-            print_permission_markdown(perm)
-
-
-def is_simple_dict(d):
-    return all(isinstance(v, (str, int, float, bool)) for v in d.values())
-
-
-def format_simple_dict_values(d):
-    # returns k=v, k=v, ...
-    return ", ".join(f"{k}={v}" for k, v in d.items())
-
-
-def print_permission_markdown(p, level=0):
-    for k, v in p.items():
-        prologue = "  " * level + f"- {k}"
-        if v is None or v == {} or v == []:
-            print(prologue)
-            continue
-        elif isinstance(v, dict):
-            if is_simple_dict(v):
-                print(f"{prologue}: {format_simple_dict_values(v)}")
-            else:
-                print(prologue)
-                print_permission_markdown(v, level + 1)
-        elif isinstance(v, list):
-            print(prologue)
-            for x in v:
-                print_permission_markdown(x, level + 1)
-        else:
-            print("  " * (level + 1) + f"{v}")
-
-
-def get_permission_documentation(policy, permission_can_name):
-    type_hints = get_type_hints(policy, include_extras=True)
-    annotation = type_hints.get(permission_can_name)
-    if annotation:
-        for md in annotation.__metadata__:
-            if isinstance(md, str):
-                return md
-    ret = default_permissions_documentation.get(permission_can_name, "")
-    return "\n".join(x.strip() for x in ret.split("\n"))
-
-
-default_permissions_documentation = {
-    # records
-    "can_create": """
-        Grants users the ability to create new records in the 
-        repository, often assigned to roles like submitters, owners, or curators.
-        The result of this action is typically a draft record.
-    """,
-    "can_read": """
-        Allows users to view or access records, with access 
-        possibly dependent on the record's state (e.g., draft or published) and the 
-        user's role.
-    """,
-    "can_read_deleted": """
-        Permission to view or access records, including soft-deleted ones. This 
-        permission is used to filter search results. It should include an 
-        `IfRecordDeleted` permission generator, which grants access to deleted 
-        records to a subset of users (e.g., owners, curators, etc.). For 
-        `service.read`, this permission is applied when record is deleted and 
-        `include_deleted` is passed; otherwise, a `RecordDeletedException` is raised.
-    """,
-    "can_search": """
-        Grants users the ability to search for records within the 
-        repository, typically available to all users. The search results are
-        filtered based on the can_read_deleted permission for published records (/api/datasets)
-        and the can_read_draft permission for draft records (/api/user/datasets).
-    """,
-    "can_update": """
-        Grants users the ability to update or modify published records.
-        In NRP repositories, this is normally disabled as updates are performed
-        on draft records, which are then published.
-    """,
-    "can_delete": """
-        Grants users the ability to delete records, often restricted 
-        to owners, curators, or specific roles, and dependent on the record's 
-        state (e.g., draft). For published records, the deletion is performed
-        via a specialized request, not directly.
-    """,
-    "can_new_version": """
-        Allows users to create a new version of a record. In NRP,
-        this is not used directly but always via a request, which is mostly
-        auto-approved.
-    """,
-    "can_edit": """
-        Grants users the ability to modify the metadata of a record. In NRP, this
-        is not used directly but always via a request, which is mostly auto-approved.
-    """,
-    "can_manage": """
-        Grants users the ability to manage records. Currently it is used just
-        for reindexing records with latest version first (reindex_latest_first)
-        service call, not mapped to REST API.
-    """,
-    "can_manage_record_access": """
-        Grants users the ability to manage record access.
-    """,
-    # draft records
-    "can_read_draft": """
-        Enables users to view or access draft records, typically equivalent to 
-        the general 'can_read' permission but specific to drafts.
-    """,
-    "can_delete_draft": """
-        Allows users to delete draft records, typically equivalent to the general 
-        'can_delete' permission but specific to drafts.
-    """,
-    "can_update_draft": """
-        Allows users to update draft records. It is typically granted to record
-        owner, but can be restricted by the record status (such as records submitted
-        to review being locked).
-    """,
-    "can_publish": """
-        Grants users the ability to publish records, making them publicly 
-        available or finalizing their state. In NRP repositories, this is
-        not used directly but always via a request.
-    """,
-    # files
-    "can_read_files": """
-        Grants users the ability to view or access file metadata associated with records, 
-        with access dependent on the record's state and the user's role.
-    """,
-    "can_create_files": """
-        Enables users to create new files within published records in the repository.
-        Normally disabled as files are created in draft records and then published.
-    """,
-    "can_delete_files": """
-        Enables users to delete files associated with published records in the repository.
-        Normally disabled as files can not be deleted from published records.
-    """,
-    "can_update_files": """
-        Enables users to update or modify files within published records in the repository.
-        Normally disabled as files are updated in draft records and then published.
-    """,
-    "can_commit_files": """
-        Allows users to finalize file upload to published records in the repository.
-        Normally disabled as files are uploaded to draft records and then published.
-    """,
-    "can_get_content_files": """
-        Allows users to access or retrieve the content of files on records published 
-        in the repository, with access depending on the record's state and the user's role.
-    """,
-    "can_manage_files": """
-        Grants users the ability to manage files (that is, change if the files are
-        required on the record or not).
-    """,
-    "can_read_deleted_files": """
-        Allows users to view or access files associated with deleted records, 
-        often restricted to specific conditions.
-    """,
-    "can_set_content_files": """
-        Enables users to upload files to published records. Normally disabled as files
-        are uploaded to draft records and then published.
-    """,
-    # draft files
-    "can_draft_read_files": """
-        Allows users to view or access file metadata associated with draft records,
-        typically equivalent to the general 'can_read_files' permission but specific
-        to drafts.
-    """,
-    "can_draft_create_files": """
-        Allows users to create files specifically for draft records.
-    """,
-    "can_draft_get_content_files": """
-        Allows users to access or retrieve the content of files on draft records.
-    """,
-    "can_draft_set_content_files": """
-        Allows users to upload files to draft records.
-    """,
-    "can_draft_commit_files": """
-        Allows users to finalize file upload to draft records.
-    """,
-    "can_draft_update_files": """
-        Allows users to update or modify files within draft records.
-    """,
-    "can_draft_delete_files": """
-        Allows users to delete files associated with draft records.
-    """,
-    # misc
-    "can_create_or_update_many": """
-        Allows bulk creation or updating of multiple records or files.
-        Not used at the moment.
-    """,
-}

oarepo_runtime/cli/permissions/search.py

@@ -1,121 +0,0 @@
-import json
-import sys
-
-import click
-import yaml
-from invenio_records_resources.proxies import current_service_registry
-
-from oarepo_runtime.info.permissions.debug import add_debugging, merge_communities
-
-from .base import get_user_and_identity, permissions
-
-
-@permissions.command(name="search")
-@click.argument("user_id_or_email")
-@click.argument("service_name")
-@click.option("--explain/--no-explain", default=False)
-@click.option("--user/--published", "user_call", default=False)
-@click.option("--full-query/--query-filters", default=False)
-@click.option("--merge-communities", "do_merge_communities", is_flag=True)
-@click.option("--json/--yaml", "as_json", default=False)
-def search_permissions(
-    user_id_or_email,
-    service_name,
-    explain,
-    user_call,
-    full_query,
-    do_merge_communities,
-    as_json,
-):
-    """Get search parameters for a given service."""
-    try:
-        service = current_service_registry.get(service_name)
-    except KeyError:
-        raise click.UsageError(
-            f"Service {service_name} not found in {current_service_registry._services.keys()}"
-        )
-    user, identity = get_user_and_identity(user_id_or_email)
-
-    permission_policy = service.config.permission_policy_cls
-
-    add_debugging(print_search=explain, print_needs=False, print_excludes=False)
-
-    if full_query:
-        previous_search = service._search
-
-        class NoExecute:
-            def __init__(self, query):
-                self.query = query
-
-            def execute(self):
-                return self.query
-
-        def _patched_search(*args, **kwargs):
-            ret = previous_search(*args, **kwargs)
-            return NoExecute(ret)
-
-        def _patched_result_list(self, identity, results, params, **kwargs):
-            return results
-
-        service._search = _patched_search
-        service.result_list = _patched_result_list
-
-        if user_call:
-            ret = service.search_drafts(identity)
-        else:
-            ret = service.search(identity)
-        ret = ret.to_dict()
-        if do_merge_communities:
-            ret = merge_communities(ret)
-        ret = {
-            "query": ret["query"],
-        }
-        dump_dict(ret, as_json)
-    else:
-
-        over = {}
-        if explain:
-            over["debug_identity"] = identity
-            print("## Explaining search:")
-
-        if user_call:
-            p = permission_policy("read_draft", identity=identity, **over)
-        else:
-            p = permission_policy("read_deleted", identity=identity, **over)
-        query_filters = p.query_filters
-
-        print()
-        print("## Query filters:")
-        for qf in query_filters:
-            dict_qf = qf.to_dict()
-            if explain:
-                dict_qf = merge_communities(dict_qf)
-            dump_dict(dict_qf, as_json)
-            print(json.dumps(dict_qf, indent=2))
-
-
-def merge_name(d):
-    if isinstance(d, list):
-        return [merge_name(x) for x in d]
-    if isinstance(d, dict):
-        ret = {}
-        for k, v in d.items():
-            v = merge_name(v)
-            if isinstance(v, dict) and "_name" in v:
-                _name = v.pop("_name")
-                _name = _name.split("@")[0].strip()
-                k = f"{k}[{_name}]"
-            ret[k] = v
-        return ret
-    return d
-
-
-def dump_dict(d, as_json=False):
-    if as_json:
-        print(json.dumps(d, indent=2))
-    else:
-        yaml.safe_dump(
-            merge_name(json.loads(json.dumps(d))),
-            sys.stdout,
-            default_flow_style=False,
-        )

oarepo_runtime/cli/validate.py

@@ -1,150 +0,0 @@
-import sys
-import traceback
-
-import click
-import yaml
-from flask.cli import with_appcontext
-from invenio_db import db
-from invenio_records import Record
-from invenio_records_resources.proxies import current_service_registry
-from tqdm import tqdm
-
-from .base import oarepo
-
-try:
-    import json5 as json
-except ImportError:
-    import json
-
-from io import StringIO
-
-
-class CheckOk(Exception):
-    pass
-
-
-def dump_data(d):
-    io = StringIO()
-    yaml.safe_dump(d, io, allow_unicode=True)
-    return io.getvalue()
-
-
-@oarepo.command(
-    help="Validate a record. Takes one or two parameters - service name as "
-    "the first one, file name or stdin with record data as the second"
-)
-@click.argument("service-name")
-@click.argument("record-file", required=False)
-@click.option("--community", help="Community name")
-@click.option("--verbose/--no-verbose", is_flag=True)
-@click.option("--with-stacktrace", is_flag=True)
-@click.option(
-    "--fail-on-error",
-    is_flag=True,
-    help="Fail on the first error (for multiple records)",
-)
-@with_appcontext
-def validate(
-    service_name, record_file, community, verbose, with_stacktrace, fail_on_error
-):
-    try:
-        service = current_service_registry.get(service_name)
-    except KeyError:
-        click.secho(f"Service {service_name} not found. Existing services:")
-        for existing in sorted(current_service_registry._services):
-            click.secho(f"    - {existing}")
-        sys.exit(1)
-
-    config = service.config
-    schema = config.schema
-
-    if not record_file:
-        file_content = sys.stdin.read().strip()
-    else:
-        with open(record_file) as f:
-            file_content = f.read()
-
-    if file_content.startswith("{"):
-        data = json.loads(file_content)
-    else:
-        data = list(yaml.safe_load_all(StringIO(file_content)))
-
-    if not isinstance(data, list):
-        data = [data]
-
-    errors_count = 0
-    for idx, d in enumerate(tqdm(data)):
-        if community:
-            d.setdefault("parent", {}).setdefault("communities", {})[
-                "default"
-            ] = community
-        try:
-            loaded = schema().load(d)
-        except Exception as e:
-            click.secho(
-                f"Marshmallow validation of record idx {idx + 1} failed",
-                fg="red",
-            )
-            click.secho(dump_data(d))
-            click.secho(e)
-            if with_stacktrace:
-                traceback.print_exc()
-            if fail_on_error:
-                sys.exit(1)
-            errors_count += 1
-            continue
-
-        if verbose:
-            click.secho(
-                f"Marshmallow validation of record idx {idx+1} has been successful",
-                fg="green",
-            )
-
-        if hasattr(config, "draft_cls"):
-            record_cls = config.draft_cls
-        else:
-            record_cls = config.record_cls
-
-        # Run pre create extensions to check vocabularies
-        try:
-            with db.session.begin_nested():
-
-                rec: Record = record_cls(
-                    loaded, model=record_cls.model_cls(id=None, data=data)
-                )
-                if record_cls.parent_record_cls:
-                    parent = record_cls.parent_record_cls(loaded["parent"])
-                    rec.parent = parent
-
-                for e in rec._extensions:
-                    e.pre_commit(rec)
-                raise CheckOk()
-        except CheckOk:
-            if verbose:
-                click.secho(
-                    f"Pre-commit hook of record idx {idx+1} has been successful",
-                    fg="green",
-                )
-        except Exception as e:
-            click.secho(
-                f"Pre-commit validation of record idx {idx + 1} failed",
-                fg="red",
-            )
-            click.secho(dump_data(d))
-            click.secho(e)
-            if with_stacktrace:
-                traceback.print_exc()
-            if fail_on_error:
-                sys.exit(1)
-            errors_count += 1
-            continue
-
-        if verbose:
-            yaml.safe_dump(loaded, sys.stdout, allow_unicode=True)
-
-    if errors_count:
-        click.secho(f"Validation finished with {errors_count} errors", fg="red")
-        sys.exit(1)
-    else:
-        click.secho("Validation finished successfully", fg="green")
-        sys.exit(0)

oarepo_runtime/datastreams/__init__.py

@@ -1,38 +0,0 @@
-from .asynchronous import AsynchronousDataStream
-from .catalogue import DataStreamCatalogue
-from .datastreams import AbstractDataStream
-from .errors import (
-    DataStreamCatalogueError,
-    DataStreamError,
-    ReaderError,
-    TransformerError,
-    WriterError,
-)
-from .json import JSON, JSONObject
-from .readers import BaseReader
-from .semi_asynchronous import SemiAsynchronousDataStream
-from .synchronous import SynchronousDataStream
-from .transformers import BaseTransformer
-from .types import DataStreamCallback, StreamBatch, StreamEntry
-from .writers import BaseWriter
-
-__all__ = [
-    "JSONObject",
-    "JSON",
-    "StreamEntry",
-    "DataStreamCatalogue",
-    "BaseReader",
-    "BaseWriter",
-    "BaseTransformer",
-    "DataStreamCatalogueError",
-    "ReaderError",
-    "WriterError",
-    "TransformerError",
-    "StreamBatch",
-    "DataStreamError",
-    "DataStreamCallback",
-    "SynchronousDataStream",
-    "AbstractDataStream",
-    "AsynchronousDataStream",
-    "SemiAsynchronousDataStream",
-]