hexwrench 0.0.1

data/README

@@ -0,0 +1,12 @@
+LICENSING warning:
+by using the Weka wrapper, you agree to use Weka and HexWrench in a GNU GPL compatible way
+
+= HexWrench
+
+== Weka
+HexWrench comes with a Weka layer, which goal is to turn Welo::Resources in
+weka.core.Instances.
+
+To use it, you need:
+- JRuby
+- A recent Weka JAR on your $LOAD_PATH

data/Rakefile

@@ -0,0 +1,46 @@
+
+require 'rubygems'
+require 'rake/gempackagetask'
+
+$LOAD_PATH.unshift('lib')
+require 'hexwrench'
+
+spec = Gem::Specification.new do |s|
+        s.name = 'hexwrench'
+        s.rubyforge_project = 'hexwrench'
+        s.version = HexWrench::VERSION
+        s.author = HexWrench::AUTHORS.first
+        s.homepage = HexWrench::WEBSITE
+        s.summary = "A data miner glue layer for your Welo resources"
+        s.email = "crapooze@gmail.com"
+        s.platform = Gem::Platform::RUBY
+
+        s.files = [
+          'Rakefile', 
+          'TODO', 
+          'README',
+          'lib/hexwrench.rb',
+          'lib/hexwrench/core/explorer.rb',
+          'lib/hexwrench/core/feature.rb',
+          'lib/hexwrench/core/resource.rb',
+          'lib/hexwrench/weka.rb',
+          'lib/hexwrench/weka/explorer.rb',
+          'lib/hexwrench/weka/feature.rb',
+        ]
+
+        s.require_path = 'lib'
+        s.bindir = 'bin'
+        s.executables = []
+        s.has_rdoc = true
+
+        s.add_dependency('welo', '>= 0.0.6')
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+        pkg.need_tar = true
+end
+
+task :gem => ["pkg/#{spec.name}-#{spec.version}.gem"] do
+        puts "generated #{spec.version}"
+end
+

data/TODO

@@ -0,0 +1,6 @@
+* related feature: 
+* explorer:
+- rename
+* weka-explorer:
+- populate attributes name on the fly
+- prepare sizes of relationships?

data/lib/hexwrench/core/explorer.rb

@@ -0,0 +1,9 @@
+
+module HexWrench
+  class Explorer
+    attr_reader :model
+    def initialize(model)
+      @model = model
+    end
+  end
+end

data/lib/hexwrench/core/feature.rb

@@ -0,0 +1,75 @@
+
+module HexWrench
+  class Feature 
+    def self.mapping
+      {:numeric => NumericFeature,
+        :date => DateFeature,
+        :nominal => NominalFeature,
+        :string => StringFeature,
+        :related => RelationFeature
+      }
+    end
+
+    def self.for(sym, resource, type)
+      raise ArgumentError.new, "not understood type: #{type}" unless mapping.has_key?(type)
+      klass = mapping[type]
+      klass.new(sym, resource)
+    end
+
+    attr_accessor :sym, :resource
+
+    def initialize(sym, resource)
+      @resource = resource
+      @sym = sym
+    end
+  end
+
+  class NumericFeature < Feature
+  end
+
+  class DateFeature < Feature
+    attr_accessor :format
+    def self.default_format
+      "%Y-%m-%d"
+    end
+
+    def initialize(sym, resource, format=nil)
+      super(sym, resource)
+      @format = format
+    end
+  end
+
+  class NominalFeature < Feature
+    attr_accessor :allowed_labels
+    def initialize(sym, resource, labels = [])
+      super(sym, resource)
+      @allowed_labels = labels
+    end
+  end
+
+  class StringFeature < Feature
+  end
+
+  class RelationFeature < Feature
+    def relationship
+      resource.relationship(sym)
+    end
+
+    def related_model_from_relationship_klass
+      Kernel.const_get relationship.klass
+    end
+
+    attr_writer :related_model
+
+    def related_model
+      @related_model || related_model_from_relationship_klass
+    end
+
+    attr_accessor :related_perspective
+
+    def related_perspective
+      @related_perspective || :default
+    end
+  end
+
+end

data/lib/hexwrench/core/resource.rb

@@ -0,0 +1,40 @@
+
+require 'welo'
+
+module HexWrench
+  module Resource
+    include Welo::Resource
+
+    def self.included(mod)
+      mod.extend Welo::Resource::ClassMethods
+      mod.extend ClassMethods
+      mod.features_hash = {}
+    end
+
+    module ClassMethods
+      attr_accessor :features_hash
+      def feature(name, type=nil)
+        if type
+          f = Feature.for(name, self, type)
+          yield f if block_given?
+          features_hash[name] = f
+        end
+        features_hash[name]
+      end
+
+      def features(persp)
+        perspective(persp).fields.map do |f|
+          feature(f)
+        end
+      end
+    end
+
+    def features(persp)
+      self.class.features(persp)
+    end
+
+    def feature(name)
+      self.class.feature(name)
+    end
+  end
+end

data/lib/hexwrench/weka/explorer.rb

@@ -0,0 +1,156 @@
+
+require 'hexwrench/core/explorer'
+
+module HexWrench
+  module Weka
+    class Explorer < HexWrench::Explorer
+      class Header #represents an ARFF-like header 
+        attr_reader :model, :perspective, :perspectives, :resources_cnt, :relation_name
+        def initialize(model, perspective_tree, resources_cnt=0, name="dummy")
+          @model = model
+          if perspective_tree.is_a?(Array)
+            @perspective = perspective_tree[0]
+            @perspectives = perspective_tree[1]
+          else
+            @perspective = perspective_tree
+            @perspectives = {}
+          end
+          @resources_cnt = resources_cnt
+          @relation_name = name
+        end
+
+        def features
+          model.perspective(perspective).fields.map do |sym|
+            model.feature(sym)
+          end
+        end
+
+        def attribute(name)
+          pair = attributes_pairs.find{|n, attr| n == name}
+          pair.last if pair
+        end
+
+        def attributes
+          attributes_pairs.map{|name, attr| attr}
+        end
+
+        def attributes_pairs
+          @attributes_pairs ||= create_attributes_pairs
+        end
+
+        def fast_vector
+          @fast_vector ||= create_fast_vector
+        end
+
+        def instances
+          @instances ||= create_instances
+        end
+
+        def create_attributes_pairs
+          features.map do |feat|
+            [feat.sym, attribute_for_feature(feat)]
+          end
+        end
+
+        # headers for related attributes
+        def headers
+          @headers ||= {}
+        end
+
+        def header(name)
+          headers[name]
+        end
+
+        def attribute_for_feature(feat)
+          name = File.join(relation_name, feat.sym.to_s)
+          case feat
+          when NumericFeature
+            Weka::Attribute.new(name)
+          when DateFeature
+            Weka::Attribute.new(name, feat.weka_format)
+          when NominalFeature
+            Weka::Attribute.new(name, feat.labels_fv)
+          when StringFeature
+            construct = Weka::Attribute.java_class.constructor(java.lang.String, 
+                                                               Weka::FastVector)
+            construct.new_instance(name, nil).to_java
+          when RelationFeature
+            related_model = feat.related_model
+            related_persp = perspectives[feat.sym] || :default 
+            cnt = 0 #XXX could be taken more cleverly if support in Welo's relationship
+            header = Header.new(related_model, related_persp, cnt, name)
+            headers[feat.sym] = header
+            construct = Weka::Attribute.java_class.constructor(java.lang.String, 
+                                                               Weka::Instances)
+            construct.new_instance(name, header.instances).to_java
+          else
+            raise ArgumentError, "don't know how to handler #{feat} to make an attribute"
+          end
+        end
+
+        def create_fast_vector
+          fv = Weka::FastVector.new
+          attributes.each do |attribute|
+            fv.add_element(attribute)
+          end
+          fv
+        end
+
+        def create_instances
+          inst = Weka::Instances.new(relation_name, fast_vector, resources_cnt)
+        end
+
+        def add_resource(resource)
+          values = features.map do |feat|
+            rb_val = resource.send(feat.sym)
+            attribute = attribute(feat.sym)
+            val = case feat
+                  when DateFeature
+                    date_str = if rb_val.respond_to?(:strftime)
+                                 fmt = feat.format || DateFeature.default_format
+                                 rb_val.send(:strftime, fmt)
+                               else
+                                 rb_val
+                               end
+                    attribute.parseDate(date_str) 
+                  when NominalFeature
+                    attribute.indexOfValue(rb_val.to_s.to_java)
+                  when StringFeature
+                    attribute.addStringValue(rb_val.to_java)
+                  when RelationFeature
+                    header = header(feat.sym)
+                    raise NotImplementedError, "no header built for #{feat} yet" unless header
+                    if feat.relationship.many?
+                      rb_val.each do |rb_val_|
+                        header.add_resource(rb_val_)
+                      end
+                    else
+                      header.add_resource(rb_val)
+                    end
+                    attribute.addRelation(header.instances)
+                  else
+                    rb_val
+                  end
+            val
+          end
+          instances.add(Weka::Instance.new(1.0, values.to_java(Java::double)))
+        end
+      end
+
+      attr_reader :headers
+
+      def initialize(model)
+        super(model)
+        @headers = {}
+      end
+
+      def header(persp)
+        @headers[persp] ||= create_header(persp)
+      end
+
+      def create_header(persp)
+        Header.new(model, persp)
+      end
+    end
+  end
+end

data/lib/hexwrench/weka/feature.rb

@@ -0,0 +1,22 @@
+
+require 'hexwrench/core/feature'
+
+module HexWrench
+  class DateFeature < Feature
+    attr_writer :weka_format
+    DEFAULT_WEKA_FORMAT = "yyyy-MM-dd"
+    def weka_format
+      @weka_format || format || DEFAULT_WEKA_FORMAT
+    end
+  end
+
+  class NominalFeature < Feature
+    def labels_fv
+      unless @labels_fv
+        @labels_fv = Weka::FastVector.new
+        allowed_labels.each{|l| @labels_fv.add_element(l.to_s)}
+      end
+      @labels_fv
+    end
+  end
+end

data/lib/hexwrench/weka.rb

@@ -0,0 +1,15 @@
+
+require 'java'
+require 'weka'
+
+require 'hexwrench/weka/feature'
+
+module HexWrench
+  module Weka
+    autoload :Explorer, 'hexwrench/weka/explorer'
+    include_class 'weka.core.Attribute'
+    include_class 'weka.core.FastVector'
+    include_class 'weka.core.Instances'
+    include_class 'weka.core.Instance'
+  end
+end

data/lib/hexwrench.rb

@@ -0,0 +1,10 @@
+
+module HexWrench
+  VERSION = "0.0.1"
+  AUTHORS = ["crapooze"]
+  WEBSITE = "https://github.com/crapooze/hexwrench"
+  LICENCE = "MIT | GPL"
+  autoload :Resource, 'hexwrench/core/resource'
+  autoload :Feature, 'hexwrench/core/feature'
+  autoload :Explorer, 'hexwrench/core/explorer'
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: hexwrench
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- crapooze
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-23 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: welo
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 0
+        - 0
+        - 6
+        version: 0.0.6
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: crapooze@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- TODO
+- README
+- lib/hexwrench.rb
+- lib/hexwrench/core/explorer.rb
+- lib/hexwrench/core/feature.rb
+- lib/hexwrench/core/resource.rb
+- lib/hexwrench/weka.rb
+- lib/hexwrench/weka/explorer.rb
+- lib/hexwrench/weka/feature.rb
+has_rdoc: true
+homepage: https://github.com/crapooze/hexwrench
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: hexwrench
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A data miner glue layer for your Welo resources
+test_files: []
+