```

then it is a "callable".

## Classes as dependencies

You might notice that to create an instance of a Python class, you use that same syntax.

For example:

```Python
class Cat:
    def __init__(self, name: str):
        self.name = name


fluffy = Cat(name="Mr Fluffy")
```

In this case, `fluffy` is an instance of the class `Cat`.

And to create `fluffy`, you are "calling" `Cat`.

)

// Standard constants for all storage class
const (
	// Reduced redundancy storage class
	RRS = "REDUCED_REDUNDANCY"
	// Standard storage class
	STANDARD = "STANDARD"
)

// Standard constats for config info storage class
const (
	ClassStandard = "standard"
	ClassRRS      = "rrs"
	Optimize      = "optimize"
	InlineBlock   = "inline_block"

	// Reduced redundancy storage class environment variable

Illustration of Jar instrumentation is shown below.

```mermaid
flowchart TB
    jar(Jar)
    modifiedJar(Jar*)
    class1("Class1")
    class2("Class2")
    class3("Class3")
    modifiedClass1("Class1*")
    modifiedClass2("Class2*")
    modifiedClass3("Class3*")
    instrumentingClassTransform{{"InstrumentingClassTransform\n(ClassVisitor)"}}
    interceptors(Generated interceptors)

					withCDIDevices("vendor1.com/class1=device1", "vendor2.com/class2=device2"),
				),
			},
			expected: &DeviceRunContainerOptions{
				Annotations: []kubecontainer.Annotation{
					{Name: "cdi.k8s.io/devicemanager_pod-container", Value: "vendor1.com/class1=device1,vendor2.com/class2=device2"},
				},
				CDIDevices: []kubecontainer.CDIDevice{
					{Name: "vendor1.com/class1=device1"},

trait CodeNarcTestFixture {
    def goodCode() {
        file("src/main/groovy/org/gradle/class1.java") << "package org.gradle; class class1 { }"
        file("src/test/groovy/org/gradle/testclass1.java") << "package org.gradle; public class testclass1 { @org.junit.Test public void test1() { } }"
        file("src/main/groovy/org/gradle/Class2.groovy") << "package org.gradle; class Class2 { }"

Ben Leggett <******@****.***> 1714764582 -0400

            .map { ClassId.topLevel(FqName(it)) }
            .filter { it.resolveToAnnotation() != null }
            .toSet()
    }

    private fun ClassId.resolveToAnnotation(): KtClass? {
        val classes = declarationProvider.getAllClassesByClassId(this)
        val annotations = classes.filterIsInstanceAnd<KtClass> { it.isAnnotation() }

        return annotations.singleOrNull()
    }
}

    public abstract fun getAllClassesByClassId(classId: ClassId): Collection<KtClassOrObject>
    public abstract fun getAllTypeAliasesByClassId(classId: ClassId): Collection<KtTypeAlias>

    public abstract fun getTopLevelKotlinClassLikeDeclarationNamesInPackage(packageFqName: FqName): Set<Name>

import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.KtClass
import org.jetbrains.kotlin.psi.KtClassOrObject
import org.jetbrains.kotlin.psi.psiUtil.contains
import kotlin.collections.filter

@OptIn(LLFirInternals::class, SymbolInternals::class)

                throw CanNotCreateSymbolPointerForLocalLibraryDeclarationException(classId?.asString() ?: name.asString())

            KaSymbolKind.CLASS_MEMBER, KaSymbolKind.TOP_LEVEL ->
                KaFirClassLikeSymbolPointer(classId!!, KaNamedClassOrObjectSymbol::class)

            else -> throw UnsupportedSymbolKind(this::class, symbolKind)
        }
    }