omniq 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

omniq/client.py

@@ -40,7 +40,7 @@ class OmniqClient:
             )
 
         if scripts_dir is None:
-            scripts_dir = default_scripts_dir(__file__)
+            scripts_dir = default_scripts_dir()
         scripts = load_scripts(r, scripts_dir)
 
         self._ops = OmniqOps(r=r, scripts=scripts)

omniq/core/scripts/ack_fail.lua

@@ -0,0 +1,119 @@
+-- ACK_FAIL (hybrid; failed kept forever; token-gated)
+-- ARGV:
+-- 1 base
+-- 2 job_id
+-- 3 now_ms
+-- 4 lease_token
+-- 5 error (optional; stored as last_error)
+
+local base        = ARGV[1]
+local job_id      = ARGV[2]
+local now_ms      = tonumber(ARGV[3] or "0")
+local lease_token = ARGV[4]
+local err_msg     = ARGV[5]  -- optional
+
+local DEFAULT_GROUP_LIMIT = 1
+local MAX_ERR_BYTES = 4096   -- bound the stored error size
+
+local k_job     = base .. ":job:" .. job_id
+local k_active  = base .. ":active"
+local k_delayed = base .. ":delayed"
+local k_failed  = base .. ":failed"
+local k_gready  = base .. ":groups:ready"
+
+local function to_i(v)
+  if v == false or v == nil or v == '' then return 0 end
+  local n = tonumber(v)
+  if n == nil then return 0 end
+  return math.floor(n)
+end
+
+local function dec_floor0(key)
+  local v = to_i(redis.call("DECR", key))
+  if v < 0 then
+    redis.call("SET", key, "0")
+    return 0
+  end
+  return v
+end
+
+local function group_limit_for(gid)
+  local k_glimit = base .. ":g:" .. gid .. ":limit"
+  local lim = to_i(redis.call("GET", k_glimit))
+  if lim <= 0 then return DEFAULT_GROUP_LIMIT end
+  return lim
+end
+
+-- NEW: bounded last_error write (optional)
+local function maybe_store_last_error()
+  if err_msg == nil or err_msg == "" then return end
+  -- best-effort truncate
+  if string.len(err_msg) > MAX_ERR_BYTES then
+    err_msg = string.sub(err_msg, 1, MAX_ERR_BYTES)
+  end
+  redis.call("HSET", k_job,
+    "last_error", err_msg,
+    "last_error_ms", tostring(now_ms)
+  )
+end
+
+-- token required
+if lease_token == nil or lease_token == "" then
+  return {"ERR", "TOKEN_REQUIRED"}
+end
+
+-- token must match the current owner attempt
+local cur_token = redis.call("HGET", k_job, "lease_token") or ""
+if cur_token ~= lease_token then
+  return {"ERR", "TOKEN_MISMATCH"}
+end
+
+-- must still be active (prevents double-ACK and stale workers after reaper/retry)
+if redis.call("ZREM", k_active, job_id) ~= 1 then
+  return {"ERR", "NOT_ACTIVE"}
+end
+
+-- NEW: store error after we confirm active+token (so stale workers can't write errors)
+maybe_store_last_error()
+
+-- group bookkeeping (if job is grouped)
+local gid = redis.call("HGET", k_job, "gid")
+if gid and gid ~= "" then
+  local k_ginflight = base .. ":g:" .. gid .. ":inflight"
+  local inflight = dec_floor0(k_ginflight)
+  local limit = group_limit_for(gid)
+  local k_gwait = base .. ":g:" .. gid .. ":wait"
+  if inflight < limit and to_i(redis.call("LLEN", k_gwait)) > 0 then
+    redis.call("ZADD", k_gready, now_ms, gid)
+  end
+end
+
+local attempt      = to_i(redis.call("HGET", k_job, "attempt"))
+local max_attempts = to_i(redis.call("HGET", k_job, "max_attempts"))
+if max_attempts <= 0 then max_attempts = 1 end
+local backoff_ms   = to_i(redis.call("HGET", k_job, "backoff_ms"))
+
+-- terminal failure => move to failed history (kept forever)
+if attempt >= max_attempts then
+  redis.call("HSET", k_job,
+    "state", "failed",
+    "updated_ms", tostring(now_ms),
+    "lease_token", "",
+    "lock_until_ms", ""
+  )
+  redis.call("LPUSH", k_failed, job_id)
+  return {"FAILED"}
+end
+
+-- retry path
+local due_ms = now_ms + backoff_ms
+redis.call("HSET", k_job,
+  "state", "delayed",
+  "due_ms", tostring(due_ms),
+  "updated_ms", tostring(now_ms),
+  "lease_token", "",
+  "lock_until_ms", ""
+)
+redis.call("ZADD", k_delayed, due_ms, job_id)
+
+return {"RETRY", tostring(due_ms)}

omniq/core/scripts/ack_success.lua

@@ -0,0 +1,90 @@
+-- ACK_SUCCESS (hybrid + retention + token-gated)
+-- ARGV:
+-- 1 base
+-- 2 job_id
+-- 3 now_ms
+-- 4 lease_token
+
+local base        = ARGV[1]
+local job_id      = ARGV[2]
+local now_ms      = tonumber(ARGV[3] or "0")
+local lease_token = ARGV[4]
+
+local DEFAULT_GROUP_LIMIT = 1
+
+local k_job       = base .. ":job:" .. job_id
+local k_active    = base .. ":active"
+local k_completed = base .. ":completed"
+local k_gready    = base .. ":groups:ready"
+
+local KEEP_COMPLETED = 100
+
+local function to_i(v)
+  if v == false or v == nil or v == '' then return 0 end
+  local n = tonumber(v)
+  if n == nil then return 0 end
+  return math.floor(n)
+end
+
+local function dec_floor0(key)
+  local v = to_i(redis.call("DECR", key))
+  if v < 0 then
+    redis.call("SET", key, "0")
+    return 0
+  end
+  return v
+end
+
+local function group_limit_for(gid)
+  local k_glimit = base .. ":g:" .. gid .. ":limit"
+  local lim = to_i(redis.call("GET", k_glimit))
+  if lim <= 0 then return DEFAULT_GROUP_LIMIT end
+  return lim
+end
+
+-- token required
+if lease_token == nil or lease_token == "" then
+  return {"ERR", "TOKEN_REQUIRED"}
+end
+
+-- token must match the current owner attempt
+local cur_token = redis.call("HGET", k_job, "lease_token") or ""
+if cur_token ~= lease_token then
+  return {"ERR", "TOKEN_MISMATCH"}
+end
+
+-- must still be active (prevents double-ACK and stale workers after reaper/retry)
+if redis.call("ZREM", k_active, job_id) ~= 1 then
+  return {"ERR", "NOT_ACTIVE"}
+end
+
+-- mark completed + clear token
+redis.call("HSET", k_job,
+  "state", "completed",
+  "updated_ms", tostring(now_ms),
+  "lease_token", "",
+  "lock_until_ms", ""
+)
+
+-- group bookkeeping (if job is grouped)
+local gid = redis.call("HGET", k_job, "gid")
+if gid and gid ~= "" then
+  local k_ginflight = base .. ":g:" .. gid .. ":inflight"
+  local inflight = dec_floor0(k_ginflight)
+  local limit = group_limit_for(gid)
+  local k_gwait = base .. ":g:" .. gid .. ":wait"
+  if inflight < limit and to_i(redis.call("LLEN", k_gwait)) > 0 then
+    redis.call("ZADD", k_gready, now_ms, gid)
+  end
+end
+
+-- retention list (trim completed list + delete overflow job hashes)
+redis.call("LPUSH", k_completed, job_id)
+while redis.call("LLEN", k_completed) > KEEP_COMPLETED do
+  local old_id = redis.call("RPOP", k_completed)
+  if old_id then
+    redis.call("DEL", base .. ":job:" .. old_id)
+  end
+end
+
+return {"OK"}

omniq/core/scripts/enqueue.lua

@@ -0,0 +1,96 @@
+-- ENQUEUE (hybrid: ungrouped by default, groups opt-in)
+-- ARGV:
+-- 1  base
+-- 2  job_id
+-- 3  payload
+-- 4  max_attempts
+-- 5  timeout_ms
+-- 6  backoff_ms
+-- 7  now_ms
+-- 8  due_ms
+-- 9  gid (optional; if set/non-empty => grouped job)
+-- 10 group_limit (optional; used to initialize the group limit if not set)
+
+local base         = ARGV[1]
+local job_id       = ARGV[2]
+local payload      = ARGV[3] or ""
+local max_attempts = tonumber(ARGV[4] or "1")
+local timeout_ms   = tonumber(ARGV[5] or "60000")
+local backoff_ms   = tonumber(ARGV[6] or "5000")
+local now_ms       = tonumber(ARGV[7] or "0")
+local due_ms       = tonumber(ARGV[8] or "0")
+local gid          = ARGV[9]
+local group_limit  = tonumber(ARGV[10] or "0")
+
+local DEFAULT_GROUP_LIMIT = 1
+
+local k_job        = base .. ":job:" .. job_id
+local k_delayed    = base .. ":delayed"
+local k_wait       = base .. ":wait"
+local k_has_groups = base .. ":has_groups"
+
+local is_grouped = (gid ~= nil and gid ~= "")
+
+-- persist job
+if is_grouped then
+  redis.call("HSET", k_job,
+    "id", job_id,
+    "payload", payload,
+    "gid", gid,
+    "state", "wait",
+    "attempt", "0",
+    "max_attempts", tostring(max_attempts),
+    "timeout_ms", tostring(timeout_ms),
+    "backoff_ms", tostring(backoff_ms),
+    "created_ms", tostring(now_ms),
+    "updated_ms", tostring(now_ms)
+  )
+
+  -- mark queue as having groups (inspection only)
+  redis.call("SET", k_has_groups, "1")
+
+  -- initialize group limit lazily (first writer wins)
+  local k_glimit = base .. ":g:" .. gid .. ":limit"
+  if group_limit ~= nil and group_limit > 0 then
+    if redis.call("EXISTS", k_glimit) == 0 then
+      redis.call("SET", k_glimit, tostring(group_limit))
+    end
+  end
+else
+  redis.call("HSET", k_job,
+    "id", job_id,
+    "payload", payload,
+    "state", "wait",
+    "attempt", "0",
+    "max_attempts", tostring(max_attempts),
+    "timeout_ms", tostring(timeout_ms),
+    "backoff_ms", tostring(backoff_ms),
+    "created_ms", tostring(now_ms),
+    "updated_ms", tostring(now_ms)
+  )
+end
+
+-- route job
+if due_ms ~= nil and due_ms > now_ms then
+  redis.call("ZADD", k_delayed, due_ms, job_id)
+  redis.call("HSET", k_job, "state", "delayed", "due_ms", tostring(due_ms))
+else
+  if is_grouped then
+    local k_gwait = base .. ":g:" .. gid .. ":wait"
+    redis.call("RPUSH", k_gwait, job_id)
+
+    -- if group has capacity, put it in the ready set
+    local k_ginflight = base .. ":g:" .. gid .. ":inflight"
+    local inflight = tonumber(redis.call("GET", k_ginflight) or "0")
+
+    local limit = tonumber(redis.call("GET", base .. ":g:" .. gid .. ":limit") or tostring(DEFAULT_GROUP_LIMIT))
+    if inflight < limit then
+      local k_gready = base .. ":groups:ready"
+      redis.call("ZADD", k_gready, now_ms, gid)
+    end
+  else
+    redis.call("RPUSH", k_wait, job_id)
+  end
+end
+
+return {"OK", job_id}

omniq/core/scripts/heartbeat.lua

@@ -0,0 +1,63 @@
+-- HEARTBEAT (lease renewal / keep-alive)
+-- Extends the lease of an active job, gated by lease_token.
+--
+-- ARGV:
+-- 1 base
+-- 2 job_id
+-- 3 now_ms
+-- 4 lease_token
+
+local base        = ARGV[1]
+local job_id      = ARGV[2]
+local now_ms      = tonumber(ARGV[3] or "0")
+local lease_token = ARGV[4]
+
+local k_job    = base .. ":job:" .. job_id
+local k_active = base .. ":active"
+
+local function to_i(v)
+  if v == false or v == nil or v == '' then return 0 end
+  local n = tonumber(v)
+  if n == nil then return 0 end
+  return math.floor(n)
+end
+
+-- token required
+if lease_token == nil or lease_token == "" then
+  return {"ERR", "TOKEN_REQUIRED"}
+end
+
+-- token must match current attempt owner
+local cur_token = redis.call("HGET", k_job, "lease_token") or ""
+if cur_token ~= lease_token then
+  return {"ERR", "TOKEN_MISMATCH"}
+end
+
+-- must still be active (prevents extending after reaper/retry)
+local cur_score = redis.call("ZSCORE", k_active, job_id)
+if not cur_score then
+  return {"ERR", "NOT_ACTIVE"}
+end
+
+local cur_lock_until = tonumber(cur_score) or 0
+
+-- extend using the job's configured timeout_ms
+local timeout_ms = to_i(redis.call("HGET", k_job, "timeout_ms"))
+if timeout_ms <= 0 then timeout_ms = 60000 end
+
+-- MONOTONIC EXTENSION:
+-- never shorten the lease if now_ms goes backwards
+local base_ms = cur_lock_until
+if now_ms > base_ms then
+  base_ms = now_ms
+end
+
+local lock_until = base_ms + timeout_ms
+
+redis.call("HSET", k_job,
+  "lock_until_ms", tostring(lock_until),
+  "updated_ms", tostring(now_ms)
+)
+redis.call("ZADD", k_active, lock_until, job_id)
+
+return {"OK", tostring(lock_until)}

omniq/core/scripts/pause.lua

@@ -0,0 +1,12 @@
+-- PAUSE QUEUE
+-- Creates a pause flag. Does not move jobs.
+
+-- ARGV:
+-- 1 base
+
+local base = ARGV[1]
+local k_paused = base .. ":paused"
+
+redis.call("SET", k_paused, "1")
+
+return "OK"

omniq/core/scripts/promote_delayed.lua

@@ -0,0 +1,59 @@
+-- PROMOTE_DELAYED (hybrid)
+-- ARGV:
+-- 1 base
+-- 2 now_ms
+-- 3 max_promote
+
+local base = ARGV[1]
+local now_ms = tonumber(ARGV[2] or "0")
+local max_promote = tonumber(ARGV[3] or "1000")
+
+local DEFAULT_GROUP_LIMIT = 1
+
+local k_delayed = base .. ":delayed"
+local k_wait    = base .. ":wait"
+local k_gready  = base .. ":groups:ready"
+
+local function to_i(v)
+  if v == false or v == nil or v == '' then return 0 end
+  local n = tonumber(v)
+  if n == nil then return 0 end
+  return math.floor(n)
+end
+
+local function group_limit_for(gid)
+  local k_glimit = base .. ":g:" .. gid .. ":limit"
+  local lim = to_i(redis.call("GET", k_glimit))
+  if lim <= 0 then return DEFAULT_GROUP_LIMIT end
+  return lim
+end
+
+local ids = redis.call("ZRANGEBYSCORE", k_delayed, "-inf", now_ms, "LIMIT", 0, max_promote)
+local promoted = 0
+
+for i=1,#ids do
+  local job_id = ids[i]
+  if redis.call("ZREM", k_delayed, job_id) == 1 then
+    local k_job = base .. ":job:" .. job_id
+    redis.call("HSET", k_job, "state", "wait", "updated_ms", tostring(now_ms))
+
+    local gid = redis.call("HGET", k_job, "gid")
+    if gid and gid ~= "" then
+      local k_gwait = base .. ":g:" .. gid .. ":wait"
+      redis.call("RPUSH", k_gwait, job_id)
+
+      -- if group has capacity, mark it as ready
+      local inflight = to_i(redis.call("GET", base .. ":g:" .. gid .. ":inflight"))
+      local limit = group_limit_for(gid)
+      if inflight < limit then
+        redis.call("ZADD", k_gready, now_ms, gid)
+      end
+    else
+      redis.call("RPUSH", k_wait, job_id)
+    end
+
+    promoted = promoted + 1
+  end
+end
+
+return {"OK", tostring(promoted)}

omniq/core/scripts/reap_expired.lua

@@ -0,0 +1,105 @@
+-- REAP_EXPIRED (stalled recovery)
+-- ARGV:
+-- 1 base
+-- 2 now_ms
+-- 3 max_reap
+
+local base = ARGV[1]
+local now_ms = tonumber(ARGV[2] or "0")
+local max_reap = tonumber(ARGV[3] or "1000")
+
+local DEFAULT_GROUP_LIMIT = 1
+
+local k_active  = base .. ":active"
+local k_delayed = base .. ":delayed"
+local k_failed  = base .. ":failed"
+local k_gready  = base .. ":groups:ready"
+
+local function to_i(v)
+  if v == false or v == nil or v == '' then return 0 end
+  local n = tonumber(v)
+  if n == nil then return 0 end
+  return math.floor(n)
+end
+
+local function dec_floor0(key)
+  local v = to_i(redis.call("DECR", key))
+  if v < 0 then
+    redis.call("SET", key, "0")
+    return 0
+  end
+  return v
+end
+
+local function group_limit_for(gid)
+  local k_glimit = base .. ":g:" .. gid .. ":limit"
+  local lim = to_i(redis.call("GET", k_glimit))
+  if lim <= 0 then return DEFAULT_GROUP_LIMIT end
+  return lim
+end
+
+local ids = redis.call("ZRANGEBYSCORE", k_active, "-inf", now_ms, "LIMIT", 0, max_reap)
+local reaped = 0
+
+for i=1,#ids do
+  local job_id = ids[i]
+
+  -- re-check current score in case lease was extended after scan
+  local score = redis.call("ZSCORE", k_active, job_id)
+  if score and tonumber(score) and tonumber(score) > now_ms then
+    -- still leased; skip
+  else
+    if redis.call("ZREM", k_active, job_id) == 1 then
+      local k_job = base .. ":job:" .. job_id
+
+      -- if job hash missing, nothing else to do
+      if redis.call("EXISTS", k_job) == 0 then
+        reaped = reaped + 1
+      else
+        -- IMPORTANT: invalidate attempt ownership
+        redis.call("HSET", k_job, "lease_token", "")
+
+        -- group bookkeeping (if grouped)
+        local gid = redis.call("HGET", k_job, "gid")
+        if gid and gid ~= "" then
+          local k_ginflight = base .. ":g:" .. gid .. ":inflight"
+          local inflight = dec_floor0(k_ginflight)
+          local limit = group_limit_for(gid)
+          local k_gwait = base .. ":g:" .. gid .. ":wait"
+          if inflight < limit and to_i(redis.call("LLEN", k_gwait)) > 0 then
+            redis.call("ZADD", k_gready, now_ms, gid)
+          end
+        end
+
+        local attempt      = to_i(redis.call("HGET", k_job, "attempt"))
+        local max_attempts = to_i(redis.call("HGET", k_job, "max_attempts"))
+        if max_attempts <= 0 then max_attempts = 1 end
+        local backoff_ms   = to_i(redis.call("HGET", k_job, "backoff_ms"))
+
+        if attempt >= max_attempts then
+          redis.call("HSET", k_job,
+            "state", "failed",
+            "updated_ms", tostring(now_ms),
+            "lease_token", "",
+            "lock_until_ms", ""
+          )
+          redis.call("LPUSH", k_failed, job_id)
+        else
+          local due_ms = now_ms + backoff_ms
+          redis.call("HSET", k_job,
+            "state", "delayed",
+            "due_ms", tostring(due_ms),
+            "updated_ms", tostring(now_ms),
+            "lease_token", "",
+            "lock_until_ms", ""
+          )
+          redis.call("ZADD", k_delayed, due_ms, job_id)
+        end
+
+        reaped = reaped + 1
+      end
+    end
+  end
+end
+
+return {"OK", tostring(reaped)}

omniq/core/scripts/reserve.lua

@@ -0,0 +1,149 @@
+-- RESERVE (hybrid: grouped + ungrouped with starvation-free fairness)
+--
+-- Returns:
+--   ["EMPTY"]
+-- or
+--   ["JOB", job_id, payload, lock_until_ms, attempt, gid, lease_token]
+--
+-- ARGV:
+-- 1 base
+-- 2 now_ms
+
+local base = ARGV[1]
+local k_paused = base .. ":paused"
+
+if redis.call("EXISTS", k_paused) == 1 then
+  return {"PAUSED"}
+end
+
+local now_ms = tonumber(ARGV[2] or "0")
+
+local DEFAULT_GROUP_LIMIT = 1
+local MAX_GROUP_POPS = 10
+
+local k_wait     = base .. ":wait"
+local k_active   = base .. ":active"
+local k_gready   = base .. ":groups:ready"
+local k_rr       = base .. ":lane:rr"
+
+-- sequence key used to generate lease tokens
+local k_token_seq = base .. ":lease:seq"
+
+local function to_i(v)
+  if v == false or v == nil or v == '' then return 0 end
+  local n = tonumber(v)
+  if n == nil then return 0 end
+  return math.floor(n)
+end
+
+local function new_lease_token(job_id)
+  local seq = redis.call("INCR", k_token_seq)
+  return redis.sha1hex(job_id .. ":" .. tostring(now_ms) .. ":" .. tostring(seq))
+end
+
+local function lease_job(job_id)
+  local k_job = base .. ":job:" .. job_id
+
+  local timeout_ms = to_i(redis.call("HGET", k_job, "timeout_ms"))
+  if timeout_ms <= 0 then timeout_ms = 60000 end
+
+  local attempt = to_i(redis.call("HGET", k_job, "attempt")) + 1
+  local lock_until = now_ms + timeout_ms
+
+  local payload = redis.call("HGET", k_job, "payload") or ""
+  local gid = redis.call("HGET", k_job, "gid") or ""
+
+  -- NEW: token per attempt
+  local lease_token = new_lease_token(job_id)
+
+  redis.call("HSET", k_job,
+    "state", "active",
+    "attempt", tostring(attempt),
+    "lock_until_ms", tostring(lock_until),
+    "lease_token", lease_token,
+    "updated_ms", tostring(now_ms)
+  )
+
+  redis.call("ZADD", k_active, lock_until, job_id)
+
+  return {"JOB", job_id, payload, tostring(lock_until), tostring(attempt), gid, lease_token}
+end
+
+local function try_ungrouped()
+  local job_id = redis.call("LPOP", k_wait)
+  if not job_id then
+    return nil
+  end
+  return lease_job(job_id)
+end
+
+local function group_limit_for(gid)
+  local k_glimit = base .. ":g:" .. gid .. ":limit"
+  local lim = to_i(redis.call("GET", k_glimit))
+  if lim <= 0 then return DEFAULT_GROUP_LIMIT end
+  return lim
+end
+
+local function try_grouped()
+  for _ = 1, MAX_GROUP_POPS do
+    local popped = redis.call("ZPOPMIN", k_gready, 1)
+    if not popped or #popped == 0 then
+      return nil
+    end
+
+    local gid = popped[1]
+    if not gid or gid == "" then
+      -- invalid gid; skip
+    else
+      local k_gwait     = base .. ":g:" .. gid .. ":wait"
+      local k_ginflight = base .. ":g:" .. gid .. ":inflight"
+
+      local inflight = to_i(redis.call("GET", k_ginflight))
+      local limit = group_limit_for(gid)
+
+      if inflight >= limit then
+        -- popped gid but no capacity: re-add with tiny delay to reduce churn
+        redis.call("ZADD", k_gready, now_ms + 1, gid)
+      else
+        local job_id = redis.call("LPOP", k_gwait)
+        if not job_id then
+          -- group empty; skip (enqueue.lua will re-add gid when new jobs arrive)
+        else
+          inflight = to_i(redis.call("INCR", k_ginflight))
+
+          if inflight < limit and to_i(redis.call("LLEN", k_gwait)) > 0 then
+            redis.call("ZADD", k_gready, now_ms, gid)
+          end
+
+          return lease_job(job_id)
+        end
+      end
+    end
+  end
+
+  return nil
+end
+
+local rr = to_i(redis.call("GET", k_rr))
+
+local res
+if rr == 0 then
+  res = try_grouped()
+  if not res then res = try_ungrouped() end
+else
+  res = try_ungrouped()
+  if not res then res = try_grouped() end
+end
+
+if not res then
+  return {"EMPTY"}
+end
+
+-- flip rr for starvation-free fairness
+if rr == 0 then
+  redis.call("SET", k_rr, "1")
+else
+  redis.call("SET", k_rr, "0")
+end
+
+return res

omniq/core/scripts/resume.lua

@@ -0,0 +1,12 @@
+-- RESUME QUEUE
+-- Removes pause flag.
+
+-- ARGV:
+-- 1 base
+
+local base = ARGV[1]
+local k_paused = base .. ":paused"
+
+local removed = redis.call("DEL", k_paused)
+
+return removed

omniq/scripts.py

@@ -17,9 +17,9 @@ class OmniqScripts:
     pause_sha: str
     resume_sha: str
 
-def default_scripts_dir(current_file: str) -> str:
-    here = os.path.dirname(os.path.abspath(current_file))
-    return os.path.abspath(os.path.join(here, "..", "..", "scripts", "scripts"))
+def default_scripts_dir() -> str:
+    here = os.path.dirname(__file__)
+    return os.path.join(here, "core", "scripts")
 
 def load_scripts(r: ScriptLoader, scripts_dir: str) -> OmniqScripts:
     def load_one(name: str) -> str:

{omniq-1.0.0.dist-info → omniq-1.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omniq
-Version: 1.0.0
+Version: 1.0.2
 Summary: OmniQ v1 - Redis+Lua queue Python SDK
 Requires-Python: >=3.9
 Requires-Dist: redis>=5.0.0

omniq-1.0.2.dist-info/RECORD

@@ -0,0 +1,23 @@
+omniq/__init__.py,sha256=PoDH4HY02Q_8tshE6OgRkPSWnGpJDvAovNWlV-NeCw0,98
+omniq/_ops.py,sha256=oSy3o1-0PRj_B1V8Ga7n7y83NpUYoxF872SDxsLpNZY,7656
+omniq/client.py,sha256=6gh1G92aUYpVWtsqTMm5m7wrpXbI5Vu6PJdV2hwGU0E,4635
+omniq/clock.py,sha256=YTpVrkx1hyop4GU9DuGXfu23n5KPsgGb_1DINiiV0FU,69
+omniq/consumer.py,sha256=z-yFYRIDX6HTD5hf4Xls7EYp5_zRw9Jc_B6RQO8o4Ws,11140
+omniq/ids.py,sha256=bGkDDZfYaZvFEnUD02TylWA05UpDYztQwndIscxFjm8,63
+omniq/monitor.py,sha256=N0qbGUJfqwUubHLvgMbemswhcQLamwsc4_5OYgqFyr0,4008
+omniq/scripts.py,sha256=LfSf7468im9k0gpICx57RAyhYqcFLYKDKN2dQRDmOxw,1246
+omniq/transport.py,sha256=4Nj-RoyZG0L0aEbCleNCF1bWQHW7J4yVgPGmebWxGPE,1309
+omniq/types.py,sha256=KXj-Z-uPV7lO3fmmyK6QYL8pJiPoYYei8UcPf0v1YUU,743
+omniq/core/scripts/ack_fail.lua,sha256=S5PemA7SGUekj-Y36YmpWWXxmYBGEsEfsZfvVBJQYcA,3342
+omniq/core/scripts/ack_success.lua,sha256=ksXl4C5RdcHg5BMXxZrP-mW0rmHehiKaF2q9jpl5By8,2349
+omniq/core/scripts/enqueue.lua,sha256=ibUeIjmwtbCarI16tNr_AzmqWHxXwqplcY4mXoXeBOY,2822
+omniq/core/scripts/heartbeat.lua,sha256=6ZUMJHTx40pwNFX6D_9-TT5vJOSioaDRV02xQszUSKY,1600
+omniq/core/scripts/pause.lua,sha256=dRCm8YcgZGzPU2Je9KQmXa3se3eV9pKe4uskO5kGdVQ,184
+omniq/core/scripts/promote_delayed.lua,sha256=IX3Lm1KMOt7OH6ZBZi5DW7QzluLdguDC-i7e23OzloM,1604
+omniq/core/scripts/reap_expired.lua,sha256=DXAJJm4jMt4ddpAKNVARSf4wG87gwkT5Rq1e6P5URx4,3106
+omniq/core/scripts/reserve.lua,sha256=L4Ty_IZATxCabHaiuJNia0BiHX9uIg-oAzdXDw-4_fI,3739
+omniq/core/scripts/resume.lua,sha256=o8NtGKkFjQT18bkQ_BkkWo406k0tVUVlyBF0DmFobUc,177
+omniq-1.0.2.dist-info/METADATA,sha256=KeAj1sFGox2ZxTAKPWw-UsXNmVo5zmPVwWjmv5iEkYA,177
+omniq-1.0.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+omniq-1.0.2.dist-info/top_level.txt,sha256=SMvOWui1e7OpLJn5BC_QsiZQIqsjhNfURCd7Ru9CuRE,6
+omniq-1.0.2.dist-info/RECORD,,

omniq-1.0.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-omniq/__init__.py,sha256=PoDH4HY02Q_8tshE6OgRkPSWnGpJDvAovNWlV-NeCw0,98
-omniq/_ops.py,sha256=oSy3o1-0PRj_B1V8Ga7n7y83NpUYoxF872SDxsLpNZY,7656
-omniq/client.py,sha256=qqG3nsfgTjGtap8hKsLJd_9vd0Iui_8aMJdJQhQCdmk,4643
-omniq/clock.py,sha256=YTpVrkx1hyop4GU9DuGXfu23n5KPsgGb_1DINiiV0FU,69
-omniq/consumer.py,sha256=z-yFYRIDX6HTD5hf4Xls7EYp5_zRw9Jc_B6RQO8o4Ws,11140
-omniq/ids.py,sha256=bGkDDZfYaZvFEnUD02TylWA05UpDYztQwndIscxFjm8,63
-omniq/monitor.py,sha256=N0qbGUJfqwUubHLvgMbemswhcQLamwsc4_5OYgqFyr0,4008
-omniq/scripts.py,sha256=E5fhtc5m6qhEwCvIz__nwSWrH0L3xGkJXRO29ajY6kI,1316
-omniq/transport.py,sha256=4Nj-RoyZG0L0aEbCleNCF1bWQHW7J4yVgPGmebWxGPE,1309
-omniq/types.py,sha256=KXj-Z-uPV7lO3fmmyK6QYL8pJiPoYYei8UcPf0v1YUU,743
-omniq-1.0.0.dist-info/METADATA,sha256=G-imH3HvAVfNKvBhNR9jwq4wFDZEWrZgfoH_8zD4q8M,177
-omniq-1.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-omniq-1.0.0.dist-info/top_level.txt,sha256=SMvOWui1e7OpLJn5BC_QsiZQIqsjhNfURCd7Ru9CuRE,6
-omniq-1.0.0.dist-info/RECORD,,