daru_lite 0.3.1 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fd692ae66f7d3b631fc1f2424f823ab3f9484bb8d7803db6ea1405b00bea456
-  data.tar.gz: 959220244151eddba5fd98abde252d54be976e80cc7e179d8cb3f61a90e3c38d
+  metadata.gz: c158868ddcdfad0c071d5ad8b583605e86cdd3a005714df2071d0fc122e88278
+  data.tar.gz: 56d1feb6d2b95f6a4c897589c56c32e8890fe72c9eb2e72d6b71a91ffc9e95ae
 SHA512:
-  metadata.gz: b4f13fe9ed18e21835c405d40d7241c5d4aea0fb391121c85a504243ac3d755a3b1c1b93f9a78befad060b59e070e234965aff233c3d68d2cac99de9f3280151
-  data.tar.gz: d084ec8cc01cb06577e686e8abbfe834d9477071342d025a9a8b3033dd43d82d39ec1d1b5d1561fcdf4508f27e3070ea5713604ffe2cb08e419f773792a34d2d
+  metadata.gz: 5ac43007818f83995648bdbc65c5debc0d8999c9623271f0d6ca7c70bccc99904b74ec48fd99860a38ad6d02f99493fecdffb6560cbf92fd6a6682eb1190c0a5
+  data.tar.gz: 3f980b1dd60846f9aba374663e34fbd0118396079e1366f7e0046c288087adbf0f7f606853dec915dd9b42109f30e2f25033ea277533a711f5be8ab2948e58f3

data/lib/daru_lite/data_frame/filterable.rb

@@ -107,9 +107,22 @@ module DaruLite
       end
 
       def keep_vector_if
-        @vectors.each do |vector|
-          delete_vector(vector) unless yield(@data[@vectors[vector]], vector)
+        vector_names = @vectors.to_a
+        kept_positions = @vectors.size.times.select do |position|
+          yield(@data[position], vector_names[position])
         end
+        kept_names = kept_positions.map { |position| vector_names[position] }
+
+        @data = kept_positions.map { |position| @data[position] }
+        @vectors =
+          if @vectors.is_a?(DaruLite::MultiIndex)
+            # An empty result can't form a MultiIndex, so it falls back to a plain Index.
+            kept_names.any? ? DaruLite::MultiIndex.from_tuples(kept_names) : DaruLite::Index.new(kept_names)
+          else
+            @vectors.class.new(kept_names)
+          end
+
+        self
       end
 
       # creates a new vector with the data of a given field which the block returns true

data/lib/daru_lite/index/categorical_index.rb

@@ -65,6 +65,22 @@ module DaruLite
       positions.size == 1 ? positions.first : positions.sort
     end
 
+    # Returns the position(s) of the given category/categories or position(s).
+    # Mirrors Index#[] but resolves against the categorical structure
+    # (@cat_hash / @array) instead of @relation_hash, which CategoricalIndex
+    # never populates.
+    # @param keys [Array<object>] categories or positions to look up
+    # @return [Integer, Array<Integer>, nil] position(s), or nil if absent
+    # @example
+    #   idx = DaruLite::CategoricalIndex.new [:a, :b, :a]
+    #   idx[:b]   # => 1
+    #   idx[:z]   # => nil
+    def [](*keys)
+      pos(*keys)
+    rescue IndexError
+      nil
+    end
+
     # Returns index value from position
     # @param pos [Integer] the position to look for
     # @return [object] category corresponding to position

data/lib/daru_lite/version.rb

@@ -1,3 +1,3 @@
 module DaruLite
-  VERSION = '0.3.1'.freeze
+  VERSION = '0.3.3'.freeze
 end

data/spec/data_frame/filterable_example.rb

@@ -340,6 +340,53 @@ shared_examples_for 'a filterable DataFrame' do
       expect(df).to eq(DaruLite::DataFrame.new({a: [1,2,3,4,5]}, order: [:a],
         index: [:one, :two, :three, :four, :five]))
     end
+
+    context "with duplicate tuples in a MultiIndex" do
+      let(:multi_index_df) do
+        DaruLite::DataFrame.new(
+          [[1, 4], [2, 5], [3, 6]],
+          order: DaruLite::MultiIndex.from_tuples([[:count, 'A'], [:count, 'A'], [:pct, 'B']]),
+          index: %w[r1 r2]
+        )
+      end
+
+      it "keeps the matching vectors without raising on the ambiguous lookup" do
+        multi_index_df.keep_vector_if { |_vector, (_metric, label)| label != 'B' }
+
+        expect(multi_index_df.vectors).to be_a(DaruLite::MultiIndex)
+        expect(multi_index_df.vectors.to_a).to eq([[:count, 'A'], [:count, 'A']])
+      end
+
+      it "does not raise when no vector is kept" do
+        expect { multi_index_df.keep_vector_if { |_vector, _tuple| false } }.not_to raise_error
+        expect(multi_index_df.vectors.to_a).to eq([])
+      end
+    end
+
+    context "with duplicate categories in a CategoricalIndex" do
+      let(:categorical_df) do
+        DaruLite::DataFrame.new(
+          [[1, 4], [2, 5], [3, 6]],
+          order: DaruLite::CategoricalIndex.new([:a, :a, :b]),
+          index: %w[r1 r2]
+        )
+      end
+
+      it "keeps the matching vectors and preserves the CategoricalIndex" do
+        categorical_df.keep_vector_if { |_vector, category| category == :a }
+
+        expect(categorical_df.vectors).to be_a(DaruLite::CategoricalIndex)
+        expect(categorical_df.vectors.to_a).to eq([:a, :a])
+        expect(categorical_df.map_vectors(&:to_a)).to eq([[1, 4], [2, 5]])
+      end
+
+      it "preserves the CategoricalIndex when no vector is kept" do
+        categorical_df.keep_vector_if { |_vector, _category| false }
+
+        expect(categorical_df.vectors).to be_a(DaruLite::CategoricalIndex)
+        expect(categorical_df.vectors.to_a).to eq([])
+      end
+    end
   end
 
   describe "#filter_vectors" do

data/spec/dataframe_spec.rb

@@ -886,6 +886,23 @@ describe DaruLite::DataFrame do
       expect(df).to eq(DaruLite::DataFrame.new({b: [11,12,14,15], a: [1,2,4,5],
       c: [11,22,44,55]}, order: [:a, :b, :c], index: [:one, :two, :four, :five]))
     end
+
+    context "when the data frame has a CategoricalIndex" do
+      let(:categorical_df) do
+        frame = DaruLite::DataFrame.new(
+          { a: [1, 2, 3], b: [11, 22, 33] },
+          order: [:a, :b],
+          index: [:base, :one, :two]
+        )
+        frame.index = DaruLite::CategoricalIndex.new([:base, :one, :two])
+        frame
+      end
+
+      it "deletes the specified row without raising" do
+        expect { categorical_df.delete_row :base }.not_to raise_error
+        expect(categorical_df.index.to_a).to eq [:one, :two]
+      end
+    end
   end
 
   context "#rename_vectors!" do

data/spec/index/categorical_index_spec.rb

@@ -68,6 +68,38 @@ describe DaruLite::CategoricalIndex do
     end
   end
 
+  describe "#[]" do
+    context "when the category occurs once" do
+      subject { index[:b] }
+
+      it { is_expected.to eq 1 }
+    end
+
+    context "when the category occurs multiple times" do
+      subject { index[:a] }
+
+      it { is_expected.to eq [0, 2, 3] }
+    end
+
+    context "when given a positional index" do
+      subject { index[0] }
+
+      it { is_expected.to eq 0 }
+    end
+
+    context "when given multiple categories" do
+      subject { index[:a, :c] }
+
+      it { is_expected.to eq [0, 2, 3, 4] }
+    end
+
+    context "when the category is absent" do
+      subject { index[:z] }
+
+      it { is_expected.to be_nil }
+    end
+  end
+
   context "#subset" do
     let(:idx) { described_class.new [:a, 1, :a, 1, :c] }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daru_lite
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.3
 platform: ruby
 authors:
 - Thomas Naude-Filonnière
@@ -9,10 +9,9 @@ authors:
 - Julie Thomas
 - Amar Slaoua
 - Mourtada Belhantri
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-17 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -317,7 +316,6 @@ description: |
   and can be used with many others like mixed_models, gnuplotrb and iruby.
 
   Daru Lite is a fork of Daru that aims to focus on data manipulation and stability.
-email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -538,7 +536,6 @@ homepage: https://github.com/pollandroll/daru
 licenses:
 - BSD-2-Clause
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -553,8 +550,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 4.0.9
 specification_version: 4
 summary: Data Analysis in RUby, stripped down
 test_files: