1. Either create several methods or a class. One solution could be to initialize an object replace each if statement with a method. To be honest I prefer more creating object for this method.
2. Nested try catch block seems complicated, can you put some comments and elaborate more on why we need a nested try catch?

this function only calls other functions and does almost nothing else.

I can't agree with it, you are doing bunch of checks and try catches, it is too much for a single function

Also pls add comments to try catch blocks, so that we will understand what it tries to catch

The idea is that, we need to isolate as much as possible, single method should either do try catch or do for loop with other function calls. It is called single responsibility principle. You can take a look at it, if use this principle our code base will be much cleaner, isolated and scalable.

there are very few checks and try catch blocks are there for a reason. This functionn also serves only one person. please try to elaborate more what you mean.

a bit complicated logic, can we separate it?

For instance we can keep for loop, create a dict:

INSTANCE_TYPE_TO_APPEND_METHOD = {
    Sample: self.append_sample,
    LinkedSample: self.append_tensor_or_partial_sample,
    Tensor: self.append_tensor_or_partial_sample,
    type(None): self.append_tensor_or_partial_sample,
    PartialSample:  self.append_tensor_or_partial_sample,
    LinkedTiledSample: self.append_tensor_or_partial_sample,
}

put this right under TransformTesnor Class before init,

and define two methods:

def self.append_sample(self, values, item):
    values.append(item.array)
  
def self.append_sample(self, values, item):
    values.append(np.asarray(item))
    
def append_item(self, values, item):
    values.append(item)

And finally this code block will look as follows:

for item in items:
    append_method = self.INSTANCE_TYPE_TO_APPEND_METHOD[type(item)]
    append_method(values, item)

    if squeeze:
         values = values[0]
     return values    

This way we will make our code more isolated and easy to understand

The idea is that, we need to isolate as much as possible, single method should either do try catch or do for loop with other function calls. It is called single responsibility principle. You can take a look at it, if use this principle our code base will be much cleaner, isolated and scalable.

Same here triple nested if statements are complicated, can we separate it?

We can create several methods. The goal is to make it more readable, and more explicit on what happens if some if statements are not satisfied.

The idea is that, we need to isolate as much as possible, single method should either do try catch or do for loop with other function calls. It is called single responsibility principle. You can take a look at it, if use this principle our code base will be much cleaner, isolated and scalable.

we can create a move the logic inside of the if statement to a new method. Also try to make if else statements more readable. Quite hard to grasp what is going on here.

The idea is that, we need to isolate as much as possible, single method should either do try catch or do for loop with other function calls. It is called single responsibility principle. You can take a look at it, if use this principle our code base will be much cleaner, isolated and scalable.

Complicated logic for a single function. Either create several methods or a class where you will isolate all if else statements and for loops

this function is only 10 lines of code

there are 2 for loops, we need to isolate it... and if else statements

The idea is that, we need to isolate as much as possible, single method should either do try catch or do for loop with other function calls. It is called single responsibility principle. You can take a look at it, if use this principle our code base will be much cleaner, isolated and scalable.

This function serves a single purpose which is to write a sample to a transform dataset. Unnecessarily separating a 10-line function for the sake of doing a for loop in another function only makes it harder to follow.

can we create a separate method for try catch block?

No, there are only 3 lines of code in the try block

The idea is that, we need to isolate as much as possible, single method should either do try catch or do for loop with other function calls. It is called single responsibility principle. You can take a look at it, if use this principle our code base will be much cleaner, isolated and scalable.

this try will catch error while a sample is being transformed. it is easier to handle compared to an error after a sample has been sent to the chunk engine.

we will only ignore SampleAppendError if ignore_errors is True

This try will catch errors from chunk engine

I can't agree with it, you are doing bunch of checks and try catches, it is too much for a single function

Also pls add comments to try catch blocks, so that we will understand what it tries to catch

The idea is that, we need to isolate as much as possible, single method should either do try catch or do for loop with other function calls. It is called single responsibility principle. You can take a look at it, if use this principle our code base will be much cleaner, isolated and scalable.

there are 2 for loops, we need to isolate it... and if else statements

The idea is that, we need to isolate as much as possible, single method should either do try catch or do for loop with other function calls. It is called single responsibility principle. You can take a look at it, if use this principle our code base will be much cleaner, isolated and scalable.

The idea is that, we need to isolate as much as possible, single method should either do try catch or do for loop with other function calls. It is called single responsibility principle. You can take a look at it, if use this principle our code base will be much cleaner, isolated and scalable.

The idea is that, we need to isolate as much as possible, single method should either do try catch or do for loop with other function calls. It is called single responsibility principle. You can take a look at it, if use this principle our code base will be much cleaner, isolated and scalable.

The idea is that, we need to isolate as much as possible, single method should either do try catch or do for loop with other function calls. It is called single responsibility principle. You can take a look at it, if use this principle our code base will be much cleaner, isolated and scalable.

The idea is that, we need to isolate as much as possible, single method should either do try catch or do for loop with other function calls. It is called single responsibility principle. You can take a look at it, if use this principle our code base will be much cleaner, isolated and scalable.