dmart 0.1.0__py3-none-any.whl

models/enums.py

@@ -0,0 +1,255 @@
+from enum import StrEnum
+import redis.commands.search.reducers as reducers
+
+
+class RequestType(StrEnum):
+    create = "create"
+    update = "update"
+    patch = "patch"
+    update_acl = "update_acl"
+    assign = "assign"
+    delete = "delete"
+    move = "move"
+
+
+class Language(StrEnum):
+    ar = "arabic"
+    en = "english"
+    ku = "kurdish"
+    fr = "french"
+    tr = "turkish"
+
+    @staticmethod
+    def code(lang_str):
+        codes = {
+            "arabic": "ar",
+            "english": "en",
+            "kurdish": "ku",
+            "french": "fr",
+            "turkish": "tr",
+        }
+        return codes[lang_str]
+
+
+class PublicSubmitResourceType(StrEnum):
+    content = "content"
+    ticket = "ticket"
+
+
+class ResourceType(StrEnum):
+    user = "user"
+    group = "group"
+    folder = "folder"
+    schema = "schema"
+    content = "content"
+    log = "log"
+    acl = "acl"
+    comment = "comment"
+    media = "media"
+    data_asset = "data_asset"
+    locator = "locator"
+    relationship = "relationship"
+    alteration = "alteration"
+    history = "history"
+    space = "space"
+    permission = "permission"
+    role = "role"
+    ticket = "ticket"
+    json = "json"
+    lock = "lock"
+    post = "post"
+    reaction = "reaction"
+    reply = "reply"
+    share = "share"
+    plugin_wrapper = "plugin_wrapper"
+    notification = "notification"
+    csv = "csv"
+    jsonl = "jsonl"
+    sqlite = "sqlite"
+    duckdb = "duckdb"
+    parquet = "parquet"
+
+
+class DataAssetType(StrEnum):
+    csv = "csv"
+    jsonl = "jsonl"
+    sqlite = "sqlite"
+    duckdb = "duckdb"
+    parquet = "parquet"
+
+
+class AttachmentType(StrEnum):
+    reaction = "reaction"
+    share = "share"
+    json = "json"
+    reply = "reply"
+    comment = "comment"
+    lock = "lock"
+    media = "media"
+    data_asset = "data_asset"
+    relationship = "relationship"
+    alteration = "alteration"
+
+
+class ContentType(StrEnum):
+    text = "text"
+    comment = "comment"
+    reaction = "reaction"
+    markdown = "markdown"
+    html = "html"
+    json = "json"
+    image = "image"
+    python = "python"
+    pdf = "pdf"
+    audio = "audio"
+    video = "video"
+    csv = "csv"
+    parquet = "parquet"
+    jsonl = "jsonl"
+    apk = "apk"
+    duckdb = "duckdb"
+    sqlite = "sqlite"
+
+    @staticmethod
+    def inline_types() -> list:
+        return [ContentType.text, ContentType.markdown, ContentType.html]
+
+
+class TaskType(StrEnum):
+    query = "query"
+
+
+class UserType(StrEnum):
+    web = "web"
+    mobile = "mobile"
+    bot = "bot"
+
+
+class ValidationEnum(StrEnum):
+    valid = "valid"
+    invalid = "invalid"
+
+
+class LockAction(StrEnum):
+    fetch = "fetch"
+    lock = "lock"
+    extend = "extend"
+    unlock = "unlock"
+    cancel = "cancel"
+
+
+class NotificationType(StrEnum):
+    admin = "admin"
+    system = "system"
+
+
+class NotificationPriority(StrEnum):
+    high = "high"
+    medium = "medium"
+    low = "low"
+
+
+class StrBoolEnum(StrEnum):
+    true = "yes"
+    false = "no"
+
+
+class ActionType(StrEnum):
+    query = "query"
+    view = "view"
+    update = "update"
+    create = "create"
+    delete = "delete"
+    attach = "attach"
+    assign = "assign"
+    move = "move"
+    progress_ticket = "progress_ticket"
+    lock = "lock"
+    unlock = "unlock"
+
+
+class ConditionType(StrEnum):
+    is_active = "is_active"
+    own = "own"
+
+
+class PluginType(StrEnum):
+    hook = "hook"
+    api = "api"
+
+
+class EventListenTime(StrEnum):
+    before = "before"
+    after = "after"
+
+
+class QueryType(StrEnum):
+    search = "search"
+    subpath = "subpath"
+    events = "events"
+    history = "history"
+    tags = "tags"
+    random = "random"
+    spaces = "spaces"
+    counters = "counters"
+    reports = "reports"
+    aggregation = "aggregation"
+    attachments = "attachments"
+    attachments_aggregation = "attachments_aggregation"
+
+
+class SortType(StrEnum):
+    ascending = "ascending"
+    descending = "descending"
+
+
+class Status(StrEnum):
+    success = "success"
+    failed = "failed"
+
+
+class RedisReducerName(StrEnum):
+    count_distinct = "count_distinct"
+    r_count = "r_count"
+    # Same as COUNT_DISTINCT - but provide an approximation instead of an exact count,
+    # at the expense of less memory and CPU in big groups
+    count_distinctish = "count_distinctish"
+    sum = "sum"
+    min = "min"
+    max = "max"
+    avg = "avg"
+    # Returns all the matched properties in a list
+    tolist = "tolist"
+    quantile = "quantile"
+    stddev = "stddev"
+    # Selects the first value within the group according to sorting parameters
+    first_value = "first_value"
+    # Returns a random sample of items from the dataset, from the given property
+    random_sample = "random_sample"
+
+    @staticmethod
+    def mapper(red: str):
+        map = {
+            "r_count": reducers.count,
+            "count_distinct": reducers.count_distinct,
+            "count_distinctish": reducers.count_distinctish,
+            "sum": reducers.sum,
+            "min": reducers.min,
+            "max": reducers.max,
+            "avg": reducers.avg,
+            "tolist": reducers.tolist,
+            "quantile": reducers.quantile,
+            "stddev": reducers.stddev,
+            "first_value": reducers.first_value,
+            "random_sample": reducers.random_sample,
+        }
+        return map[red]
+
+
+class ReactionType(StrEnum):
+    like = "like"
+    dislike = "dislike"
+    love = "love"
+    care = "care"
+    laughing = "laughing"
+    sad = "sad"

password_gen.py

@@ -0,0 +1,8 @@
+#!/usr/bin/env python3
+
+from utils.password_hashing import hash_password
+
+print("Enter the password: ", end="")
+password = input()
+print("Generated hash: ", end="")
+print(hash_password(password))

pytests/api_user_models_erros_test.py

@@ -0,0 +1,16 @@
+import pytest
+from models.api import Error
+from utils.internal_error_code import InternalErrorCode
+from api.user.model.errors import INVALID_OTP, EXPIRED_OTP
+
+def test_invalid_otp():
+    assert isinstance(INVALID_OTP, Error)
+    assert INVALID_OTP.type == "OTP"
+    assert INVALID_OTP.code == InternalErrorCode.OTP_INVALID
+    assert INVALID_OTP.message == "Invalid OTP"
+
+def test_expired_otp():
+    assert isinstance(EXPIRED_OTP, Error)
+    assert EXPIRED_OTP.type == "OTP"
+    assert EXPIRED_OTP.code == InternalErrorCode.OTP_EXPIRED
+    assert EXPIRED_OTP.message == "Expired OTP"

pytests/api_user_models_requests_test.py

@@ -0,0 +1,98 @@
+import pytest
+from pydantic import ValidationError
+
+from api.user.model.requests import (
+    OTPType,
+    SendOTPRequest,
+    PasswordResetRequest,
+    ConfirmOTPRequest,
+    UserLoginRequest,
+    Exception,
+    Error,
+    InternalErrorCode
+)
+import utils.regex as rgx
+
+
+def test_send_otp_request_valid_msisdn():
+    request = SendOTPRequest(msisdn="7777778110")
+    result = request.check_fields()
+    assert result == {"msisdn": "7777778110"}
+
+def test_send_otp_request_valid_email():
+    request = SendOTPRequest(email="test@example.com")
+    result = request.check_fields()
+    assert result == {"email": "test@example.com"}
+
+def test_send_otp_request_missing_fields():
+    # Ensure both fields are explicitly None
+    with pytest.raises(Exception) as excinfo:
+        SendOTPRequest(msisdn=None, email=None).check_fields()
+    assert excinfo.value.status_code == 422
+    assert excinfo.value.error.code == InternalErrorCode.EMAIL_OR_MSISDN_REQUIRED
+
+def test_send_otp_request_too_many_fields():
+    with pytest.raises(Exception) as excinfo:
+        SendOTPRequest(msisdn="7777778110", email="test@example.com").check_fields()
+    assert excinfo.value.status_code == 422
+    assert excinfo.value.error.code == InternalErrorCode.INVALID_STANDALONE_DATA
+
+def test_password_reset_request_valid_msisdn():
+    request = PasswordResetRequest(msisdn="7777778110")
+    result = request.check_fields()
+    assert result == {"msisdn": "7777778110"}
+
+def test_password_reset_request_valid_email():
+    request = PasswordResetRequest(email="test@example.com")
+    result = request.check_fields()
+    assert result == {"email": "test@example.com"}
+
+def test_password_reset_request_missing_fields():
+    with pytest.raises(Exception) as excinfo:
+        PasswordResetRequest().check_fields()
+    assert excinfo.value.status_code == 422
+    assert excinfo.value.error.code == InternalErrorCode.EMAIL_OR_MSISDN_REQUIRED
+
+def test_password_reset_request_too_many_fields():
+    with pytest.raises(Exception) as excinfo:
+        PasswordResetRequest(msisdn="7777778110", email="test@example.com").check_fields()
+    assert excinfo.value.status_code == 422
+    assert excinfo.value.error.code == InternalErrorCode.INVALID_STANDALONE_DATA
+
+def test_confirm_otp_request_valid():
+    request = ConfirmOTPRequest(msisdn="7777778110", code="123456")
+    assert request.msisdn == "7777778110"
+    assert request.code == "123456"
+
+def test_confirm_otp_request_invalid_code():
+    with pytest.raises(ValidationError):
+        ConfirmOTPRequest(msisdn="7777778110", code="invalid")
+
+def test_user_login_request_valid_shortname():
+    request = UserLoginRequest(shortname="john_doo", password="my_secure_password_@_93301")
+    result = request.check_fields()
+    assert result == {"shortname": "john_doo"}
+
+def test_user_login_request_valid_email():
+    request = UserLoginRequest(email="test@example.com", password="my_secure_password_@_93301")
+    result = request.check_fields()
+    assert result == {"email": "test@example.com"}
+
+def test_user_login_request_valid_msisdn():
+    request = UserLoginRequest(msisdn="7777778110", password="my_secure_password_@_93301")
+    result = request.check_fields()
+    assert result == {"msisdn": "7777778110"}
+
+def test_user_login_request_missing_fields():
+    request = UserLoginRequest(password="my_secure_password_@_93301")
+    result = request.check_fields()
+    assert result == {}
+
+def test_user_login_request_too_many_fields():
+    with pytest.raises(ValueError, match="Too many input has been passed"):
+        UserLoginRequest(shortname="john_doo", email="test@example.com", msisdn="7777778110", password="my_secure_password_@_93301").check_fields()
+
+def test_user_login_request_missing_password():
+    request = UserLoginRequest(shortname="john_doo")
+    result = request.check_fields()
+    assert result == {"shortname": "john_doo"}

pytests/archive_test.py

@@ -0,0 +1,72 @@
+# import pytest
+# from unittest.mock import patch
+# from time import time
+# import argparse
+# import asyncio
+# from archive import redis_doc_to_meta, archive
+#
+#
+# def test_redis_doc_to_meta():
+#     mock_record = {
+#         "resource_type": "record",
+#         "created_at": time(),
+#         "updated_at": time(),
+#     }
+#     expected_keys = ["resource_type", "created_at", "updated_at"]
+#     with patch("models.core.Record") as MockRecord:
+#         MockRecord.model_fields.keys.return_value = expected_keys
+#         MockRecord.model_validate.return_value = mock_record
+#         meta = redis_doc_to_meta(mock_record)
+#         assert meta == mock_record
+#         assert MockRecord.model_fields.keys.call_count == 3
+#         MockRecord.model_validate.assert_called_once()
+#
+# def main():
+#     parser = argparse.ArgumentParser(
+#         description="Script for archiving records from different spaces and subpaths."
+#     )
+#     parser.add_argument("space", type=str, help="The name of the space")
+#     parser.add_argument("subpath", type=str, help="The subpath within the space")
+#     parser.add_argument(
+#         "schema",
+#         type=str,
+#         help="The subpath within the space. Optional, if not provided move everything",
+#         nargs="?",
+#     )
+#     parser.add_argument(
+#         "olderthan",
+#         type=int,
+#         help="The number of day, older than which, the entries will be archived (based on updated_at)",
+#     )
+#
+#     args = parser.parse_args()
+#     space = args.space
+#     subpath = args.subpath
+#     olderthan = args.olderthan
+#     schema = args.schema or "meta"
+#
+#     asyncio.run(archive(space, subpath, schema, olderthan))
+#     print("Done.")
+#
+#
+# @pytest.mark.asyncio
+# @patch("argparse.ArgumentParser.parse_args")
+# @patch("archive.archive")
+# async def test_main(mock_archive, mock_parse_args):
+#     mock_args = argparse.Namespace(
+#         space="space",
+#         subpath="subpath",
+#         schema="schema",
+#         olderthan=1
+#     )
+#     mock_parse_args.return_value = mock_args
+#
+#     with patch("asyncio.run") as mock_asyncio_run:
+#         mock_asyncio_run.side_effect = lambda x: asyncio.ensure_future(x)
+#         main()
+#
+#     mock_parse_args.assert_called_once()
+#     mock_asyncio_run.assert_called_once()
+#
+# if __name__ == "__main__":
+#     pytest.main()