support for working with class

README.md

@@ -533,6 +533,55 @@ optional arguments after:
 >>>
 ```
 
+### Organizing using class
+
+You can also organize pipes using classes as shown below:
+
+>>> class Factor:
+...     n: int = 10
+... 
+...     def __init__(self, n: int):
+...         self.n = n
+... 
+...     @Pipe
+...     def mul(self, iterable):
+...         return (x * self.n for x in iterable)
+... 
+>>> fact = Factor(10)
+>>> list([1, 2, 3] | fact.mul)
+[10, 20, 30]
+
+Supported on classmethod
+
+>>> class Factor:
+...     n: int = 10
+... 
+...     def __init__(self, n: int):
+...         self.n = n
+... 
+...     @Pipe
+...     @classmethod
+...     def mul(cls, iterable):
+...         return (x * cls.n for x in iterable)
+... 
+>>> list([1, 2, 3] | Factor.mul)
+[10, 20, 30]
+
+Supported on classmethod like functions
+
+>>> class Factor:
+...     n: int = 10
+... 
+...     def __init__(self, n: int):
+...         self.n = n
+... 
+...     @Pipe
+...     def mul(cls, iterable):
+...         return (x * cls.n for x in iterable)
+... 
+>>> list([1, 2, 3] | Factor.mul)
+[10, 20, 30]
+
 
 ## One-off pipes
 

pipe.py

@@ -8,12 +8,28 @@
 import functools
 import itertools
 import socket
+import inspect
 import sys
 from contextlib import closing
 from collections import deque
 import builtins
 
 
+def _is_a_classmethod(func):
+    """
+    Check if a given function is a class method.
+
+    Args:
+        func (function): The function to check.
+
+    Returns:
+        bool: True if the function is a class method, False otherwise.
+    """
+    signature = inspect.signature(func)
+    parameters = list(signature.parameters.values())
+    return len(parameters) > 0 and parameters[0].name == "cls"
+
+
 class Pipe:
     """
     Represent a Pipeable Element :
@@ -33,21 +49,49 @@ class Pipe:
     """
 
     def __init__(self, function, *args, **kwargs):
-        self.function = lambda iterable, *args2, **kwargs2: function(
-            iterable, *args, *args2, **kwargs, **kwargs2
-        )
+        self.args = args
+        self.kwargs = kwargs
+        self.function = function
+        self.instance = None
         functools.update_wrapper(self, function)
 
     def __ror__(self, other):
-        return self.function(other)
+        bound_args = [] if self.instance is None else [self.instance]
+        return self.function(*bound_args, other, *self.args, **self.kwargs)
 
     def __call__(self, *args, **kwargs):
         return Pipe(
-            lambda iterable, *args2, **kwargs2: self.function(
-                iterable, *args, *args2, **kwargs, **kwargs2
-            )
+            self.function,
+            *self.args,
+            *args,
+            **self.kwargs,
+            **kwargs,
         )
 
+    def __repr__(self) -> str:
+        return "piped::<%s>(*%s, **%s)" % (
+            self.function.__name__,
+            self.args,
+            self.kwargs,
+        )
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            if owner is None:  # pragma: no cover
+                return self
+            if isinstance(self.function, classmethod):
+                self.instance = owner
+                self.function = self.function.__func__.__get__(None, owner)
+                return self
+            if _is_a_classmethod(self.function):
+                # function is like a classmethod, but not a classmethod
+                # only the first argument is the class, name it cls
+                self.instance = owner
+                return self  # pragma: no cover
+            return self
+        self.instance = instance
+        return self
+
 
 @Pipe
 def take(iterable, qte):

tests/test_pipe.py

@@ -39,3 +39,31 @@ def test_enumerate():
     data = [4, "abc", {"key": "value"}]
     expected = [(5, 4), (6, "abc"), (7, {"key": "value"})]
     assert list(data | pipe.enumerate(start=5)) == expected
+
+
+def test_class_support():
+    class Factory:
+        n = 10
+
+        @pipe.Pipe
+        def mul(self, iterable):
+            return (x * self.n for x in iterable)
+
+    assert list([1, 2, 3] | Factory().mul) == [10, 20, 30]
+
+
+def test_pipe_repr():
+    @pipe.Pipe
+    def sample_pipe(iterable):
+        return (x * 2 for x in iterable)
+
+    assert repr(sample_pipe) == "piped::<sample_pipe>(*(), **{})"
+
+    @pipe.Pipe
+    def sample_pipe_with_args(iterable, factor):
+        return (x * factor for x in iterable)
+
+    pipe_instance = sample_pipe_with_args(3)
+    real_repr = repr(pipe_instance)
+    assert "piped::<sample_pipe_with_args>(" in real_repr
+    assert "3" in real_repr