aiqa-client 0.1.6__py3-none-any.whl → 0.2.1__py3-none-any.whl

aiqa/__init__.py

@@ -4,26 +4,28 @@ Python client for AIQA server - OpenTelemetry tracing decorators.
 
 from .tracing import (
     WithTracing,
-    flush_spans,
+    flush_tracing,
     shutdown_tracing,
     set_span_attribute,
     set_span_name,
     get_active_span,
-    provider,
-    exporter,
+    get_provider,
+    get_exporter,
 )
+from .client import get_client
 
-__version__ = "0.1.6"
+__version__ = "0.2.1"
 
 __all__ = [
     "WithTracing",
-    "flush_spans",
+    "flush_tracing",
     "shutdown_tracing",
     "set_span_attribute",
     "set_span_name",
     "get_active_span",
-    "provider",
-    "exporter",
+    "get_provider",
+    "get_exporter",
+    "get_client",
     "__version__",
 ]
 

aiqa/aiqa_exporter.py

@@ -65,7 +65,7 @@ class AIQASpanExporter(SpanExporter):
         if not spans:
             logger.debug("export() called with empty spans list")
             return SpanExportResult.SUCCESS
-
+        logger.debug(f"AIQA export() called with {len(spans)} spans")
         # Serialize and add to buffer
         with self.buffer_lock:
             serialized_spans = [self._serialize_span(span) for span in spans]

aiqa/client.py

@@ -0,0 +1,49 @@
+# aiqa/client.py
+import os
+from functools import lru_cache
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+from .aiqa_exporter import AIQASpanExporter
+
+AIQA_TRACER_NAME = "aiqa-tracer"
+
+client = {
+	"provider": None,
+	"exporter": None,
+}
+
+@lru_cache(maxsize=1)
+def get_client():
+    global client
+    _init_tracing()
+    # optionally return a richer client object; for now you just need init    
+    return client
+
+def _init_tracing():
+    provider = trace.get_tracer_provider()
+
+    # If it's still the default proxy, install a real SDK provider
+    if not isinstance(provider, TracerProvider):
+        provider = TracerProvider()
+        trace.set_tracer_provider(provider)
+
+    # Idempotently add your processor
+    _attach_aiqa_processor(provider)
+    global client
+    client["provider"] = provider
+
+def _attach_aiqa_processor(provider: TracerProvider):
+    # Avoid double-adding if get_client() is called multiple times
+    for p in provider._active_span_processor._span_processors:
+        if isinstance(getattr(p, "exporter", None), AIQASpanExporter):
+            return
+
+    exporter = AIQASpanExporter(
+        server_url=os.getenv("AIQA_SERVER_URL"),
+        api_key=os.getenv("AIQA_API_KEY"),
+    )
+    provider.add_span_processor(BatchSpanProcessor(exporter))
+    global client
+    client["exporter"] = exporter

aiqa/tracing.py

@@ -18,31 +18,12 @@ from opentelemetry.semconv.resource import ResourceAttributes
 from opentelemetry.trace import Status, StatusCode
 from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
 from .aiqa_exporter import AIQASpanExporter
+from .client import get_client, AIQA_TRACER_NAME
 
 logger = logging.getLogger(__name__)
 
-# Load environment variables
-exporter = AIQASpanExporter()
 
-# Initialize OpenTelemetry
-# Use ALWAYS_ON sampler to ensure all spans are recorded (important for FastAPI async contexts)
-provider = TracerProvider(
-    resource=Resource.create(
-        {
-            ResourceAttributes.SERVICE_NAME: os.getenv("OTEL_SERVICE_NAME", "aiqa-service"),
-        }
-    ),
-    sampler=ALWAYS_ON
-)
-
-provider.add_span_processor(BatchSpanProcessor(exporter))
-trace.set_tracer_provider(provider)
-
-# Get a tracer instance
-tracer = trace.get_tracer("aiqa-tracer")
-
-
-async def flush_spans() -> None:
+async def flush_tracing() -> None:
     """
     Flush all pending spans to the server.
     Flushes also happen automatically every few seconds. So you only need to call this function
@@ -50,8 +31,11 @@ async def flush_spans() -> None:
 
     This flushes both the BatchSpanProcessor and the exporter buffer.
     """
-    provider.force_flush()  # Synchronous method
-    await exporter.flush()
+    client = get_client()
+    if client.get("provider"):
+        client["provider"].force_flush()  # Synchronous method
+    if client.get("exporter"):    
+        await client["exporter"].flush()
 
 
 async def shutdown_tracing() -> None:
@@ -59,12 +43,18 @@ async def shutdown_tracing() -> None:
     Shutdown the tracer provider and exporter.
     It is not necessary to call this function.
     """
-    provider.shutdown()  # Synchronous method
-    await exporter.shutdown()
+    try:
+        client = get_client()
+        if client.get("provider"):
+            client["provider"].shutdown()  # Synchronous method
+        if client.get("exporter"):
+            await client["exporter"].shutdown() # async method
+    except Exception as e:
+        logger.error(f"Error shutting down tracing: {e}", exc_info=True)
 
 
-# Export provider and exporter for advanced usage
-__all__ = ["provider", "exporter", "flush_spans", "shutdown_tracing", "WithTracing", "set_span_attribute", "set_span_name", "get_active_span"]
+# Export provider and exporter accessors for advanced usage
+__all__ = ["get_provider", "get_exporter", "flush_tracing", "shutdown_tracing", "WithTracing", "set_span_attribute", "set_span_name", "get_active_span"]
 
 
 class TracingOptions:
@@ -129,6 +119,181 @@ def _prepare_input(args: tuple, kwargs: dict) -> Any:
     return result
 
 
+def _prepare_and_filter_input(
+    args: tuple,
+    kwargs: dict,
+    filter_input: Optional[Callable[[Any], Any]],
+    ignore_input: Optional[Any],
+) -> Any:
+    """Prepare and filter input for span attributes."""
+    input_data = _prepare_input(args, kwargs)
+    if filter_input:
+        input_data = filter_input(input_data)
+    if ignore_input and isinstance(input_data, dict):
+        for key in ignore_input:
+            if key in input_data:
+                del input_data[key]
+    return input_data
+
+
+def _prepare_and_filter_output(
+    result: Any,
+    filter_output: Optional[Callable[[Any], Any]],
+    ignore_output: Optional[Any],
+) -> Any:
+    """Prepare and filter output for span attributes."""
+    output_data = result
+    if filter_output:
+        output_data = filter_output(output_data)
+    if ignore_output and isinstance(output_data, dict):
+        output_data = output_data.copy()
+        for key in ignore_output:
+            if key in output_data:
+                del output_data[key]
+    return output_data
+
+
+def _handle_span_exception(span: trace.Span, exception: Exception) -> None:
+    """Record exception on span and set error status."""
+    error = exception if isinstance(exception, Exception) else Exception(str(exception))
+    span.record_exception(error)
+    span.set_status(Status(StatusCode.ERROR, str(error)))
+
+
+class TracedGenerator:
+    """Wrapper for sync generators that traces iteration."""
+    
+    def __init__(
+        self,
+        generator: Any,
+        span: trace.Span,
+        fn_name: str,
+        filter_output: Optional[Callable[[Any], Any]],
+        ignore_output: Optional[Any],
+        context_token: Any,
+    ):
+        self._generator = generator
+        self._span = span
+        self._fn_name = fn_name
+        self._filter_output = filter_output
+        self._ignore_output = ignore_output
+        self._context_token = context_token
+        self._yielded_values = []
+        self._exhausted = False
+    
+    def __iter__(self):
+        return self
+    
+    def __next__(self):
+        if self._exhausted:
+            raise StopIteration
+        
+        try:
+            value = next(self._generator)
+            self._yielded_values.append(value)
+            return value
+        except StopIteration:
+            self._exhausted = True
+            self._finalize_span_success()
+            trace.context_api.detach(self._context_token)
+            self._span.end()
+            raise
+        except Exception as exception:
+            self._exhausted = True
+            _handle_span_exception(self._span, exception)
+            trace.context_api.detach(self._context_token)
+            self._span.end()
+            raise
+    
+    def _finalize_span_success(self):
+        """Set output and success status on span."""
+        # Record summary of yielded values
+        output_data = {
+            "type": "generator",
+            "yielded_count": len(self._yielded_values),
+        }
+        
+        # Optionally include sample values (limit to avoid huge spans)
+        if self._yielded_values:
+            sample_size = min(10, len(self._yielded_values))
+            output_data["sample_values"] = [
+                _serialize_for_span(v) for v in self._yielded_values[:sample_size]
+            ]
+            if len(self._yielded_values) > sample_size:
+                output_data["truncated"] = True
+        
+        output_data = _prepare_and_filter_output(output_data, self._filter_output, self._ignore_output)
+        self._span.set_attribute("output", _serialize_for_span(output_data))
+        self._span.set_status(Status(StatusCode.OK))
+
+
+class TracedAsyncGenerator:
+    """Wrapper for async generators that traces iteration."""
+    
+    def __init__(
+        self,
+        generator: Any,
+        span: trace.Span,
+        fn_name: str,
+        filter_output: Optional[Callable[[Any], Any]],
+        ignore_output: Optional[Any],
+        context_token: Any,
+    ):
+        self._generator = generator
+        self._span = span
+        self._fn_name = fn_name
+        self._filter_output = filter_output
+        self._ignore_output = ignore_output
+        self._context_token = context_token
+        self._yielded_values = []
+        self._exhausted = False
+    
+    def __aiter__(self):
+        return self
+    
+    async def __anext__(self):
+        if self._exhausted:
+            raise StopAsyncIteration
+        
+        try:
+            value = await self._generator.__anext__()
+            self._yielded_values.append(value)
+            return value
+        except StopAsyncIteration:
+            self._exhausted = True
+            self._finalize_span_success()
+            trace.context_api.detach(self._context_token)
+            self._span.end()
+            raise
+        except Exception as exception:
+            self._exhausted = True
+            _handle_span_exception(self._span, exception)
+            trace.context_api.detach(self._context_token)
+            self._span.end()
+            raise
+    
+    def _finalize_span_success(self):
+        """Set output and success status on span."""
+        # Record summary of yielded values
+        output_data = {
+            "type": "async_generator",
+            "yielded_count": len(self._yielded_values),
+        }
+        
+        # Optionally include sample values (limit to avoid huge spans)
+        if self._yielded_values:
+            sample_size = min(10, len(self._yielded_values))
+            output_data["sample_values"] = [
+                _serialize_for_span(v) for v in self._yielded_values[:sample_size]
+            ]
+            if len(self._yielded_values) > sample_size:
+                output_data["truncated"] = True
+        
+        output_data = _prepare_and_filter_output(output_data, self._filter_output, self._ignore_output)
+        self._span.set_attribute("output", _serialize_for_span(output_data))
+        self._span.set_status(Status(StatusCode.OK))
+
+
 def WithTracing(
     func: Optional[Callable] = None,
     *,
@@ -142,7 +307,7 @@ def WithTracing(
     Decorator to automatically create spans for function calls.
     Records input/output as span attributes. Spans are automatically linked via OpenTelemetry context.
     
-    Works with both synchronous and asynchronous functions.
+    Works with synchronous functions, asynchronous functions, generator functions, and async generator functions.
     
     Args:
         func: The function to trace (when used as @WithTracing)
@@ -161,6 +326,16 @@ def WithTracing(
         async def my_async_function(x, y):
             return x + y
         
+        @WithTracing
+        def my_generator(n):
+            for i in range(n):
+                yield i * 2
+        
+        @WithTracing
+        async def my_async_generator(n):
+            for i in range(n):
+                yield i * 2
+        
         @WithTracing(name="custom_name")
         def another_function():
             pass
@@ -174,64 +349,137 @@ def WithTracing(
             return fn
         
         is_async = inspect.iscoroutinefunction(fn)
+        is_generator = inspect.isgeneratorfunction(fn)
+        is_async_generator = inspect.isasyncgenfunction(fn) if hasattr(inspect, 'isasyncgenfunction') else False
+        
+        tracer = trace.get_tracer(AIQA_TRACER_NAME)
+        
+        def _setup_span(span: trace.Span, input_data: Any) -> bool:
+            """Setup span with input data. Returns True if span is recording."""
+            if not span.is_recording():
+                logger.warning(f"Span {fn_name} is not recording - will not be exported")
+                return False
+            
+            logger.debug(f"Span {fn_name} is recording, trace_id={format(span.get_span_context().trace_id, '032x')}")
+            
+            if input_data is not None:
+                span.set_attribute("input", _serialize_for_span(input_data))
+            
+            trace_id = format(span.get_span_context().trace_id, "032x")
+            logger.debug(f"do traceable stuff {fn_name} {trace_id}")
+            return True
+        
+        def _finalize_span_success(span: trace.Span, result: Any) -> None:
+            """Set output and success status on span."""
+            output_data = _prepare_and_filter_output(result, filter_output, ignore_output)
+            span.set_attribute("output", _serialize_for_span(output_data))
+            span.set_status(Status(StatusCode.OK))
+        
+        def _execute_with_span_sync(executor: Callable[[], Any], input_data: Any) -> Any:
+            """Execute sync function within span context, handling input/output and exceptions."""
+            with tracer.start_as_current_span(fn_name) as span:
+                if not _setup_span(span, input_data):
+                    return executor()
+                
+                try:
+                    result = executor()
+                    _finalize_span_success(span, result)
+                    return result
+                except Exception as exception:
+                    _handle_span_exception(span, exception)
+                    raise
+        
+        async def _execute_with_span_async(executor: Callable[[], Any], input_data: Any) -> Any:
+            """Execute async function within span context, handling input/output and exceptions."""
+            with tracer.start_as_current_span(fn_name) as span:
+                if not _setup_span(span, input_data):
+                    return await executor()
+                
+                try:
+                    result = await executor()
+                    _finalize_span_success(span, result)
+                    logger.debug(f"Span {fn_name} completed successfully, is_recording={span.is_recording()}")
+                    return result
+                except Exception as exception:
+                    _handle_span_exception(span, exception)
+                    raise
+                finally:
+                    logger.debug(f"Span {fn_name} context exiting, is_recording={span.is_recording()}")
+        
+        def _execute_generator_sync(executor: Callable[[], Any], input_data: Any) -> Any:
+            """Execute sync generator function, returning a traced generator."""
+            # Create span but don't use 'with' - span will be closed by TracedGenerator
+            span = tracer.start_span(fn_name)
+            token = trace.context_api.attach(trace.context_api.set_span_in_context(span))
+            
+            try:
+                if not _setup_span(span, input_data):
+                    generator = executor()
+                    trace.context_api.detach(token)
+                    span.end()
+                    return generator
+                
+                generator = executor()
+                return TracedGenerator(generator, span, fn_name, filter_output, ignore_output, token)
+            except Exception as exception:
+                trace.context_api.detach(token)
+                _handle_span_exception(span, exception)
+                span.end()
+                raise
+        
+        async def _execute_generator_async(executor: Callable[[], Any], input_data: Any) -> Any:
+            """Execute async generator function, returning a traced async generator."""
+            # Create span but don't use 'with' - span will be closed by TracedAsyncGenerator
+            span = tracer.start_span(fn_name)
+            token = trace.context_api.attach(trace.context_api.set_span_in_context(span))
+            
+            try:
+                if not _setup_span(span, input_data):
+                    generator = await executor()
+                    trace.context_api.detach(token)
+                    span.end()
+                    return generator
+                
+                generator = await executor()
+                return TracedAsyncGenerator(generator, span, fn_name, filter_output, ignore_output, token)
+            except Exception as exception:
+                trace.context_api.detach(token)
+                _handle_span_exception(span, exception)
+                span.end()
+                raise
         
-        if is_async:
+        if is_async_generator:
+            @wraps(fn)
+            async def async_gen_traced_fn(*args, **kwargs):
+                input_data = _prepare_and_filter_input(args, kwargs, filter_input, ignore_input)
+                return await _execute_generator_async(
+                    lambda: fn(*args, **kwargs),
+                    input_data
+                )
+            
+            async_gen_traced_fn._is_traced = True
+            logger.debug(f"Function {fn_name} is now traced (async generator)")
+            return async_gen_traced_fn
+        elif is_generator:
+            @wraps(fn)
+            def gen_traced_fn(*args, **kwargs):
+                input_data = _prepare_and_filter_input(args, kwargs, filter_input, ignore_input)
+                return _execute_generator_sync(
+                    lambda: fn(*args, **kwargs),
+                    input_data
+                )
+            
+            gen_traced_fn._is_traced = True
+            logger.debug(f"Function {fn_name} is now traced (generator)")
+            return gen_traced_fn
+        elif is_async:
             @wraps(fn)
             async def async_traced_fn(*args, **kwargs):
-                # Prepare input
-                input_data = _prepare_input(args, kwargs)
-                if filter_input:
-                    input_data = filter_input(input_data)
-                if ignore_input and isinstance(input_data, dict):                    
-                    for key in ignore_input:
-                        if key in input_data:
-                            del input_data[key]
-                
-                # Use start_as_current_span to ensure span is recorded by BatchSpanProcessor
-                with tracer.start_as_current_span(fn_name) as span:
-                    # Check if span is recording - if not, spans won't be exported
-                    if not span.is_recording():
-                        logger.warning(f"Span {fn_name} is not recording - will not be exported")
-                        return await fn(*args, **kwargs)
-                    
-                    logger.debug(f"Span {fn_name} is recording, trace_id={format(span.get_span_context().trace_id, '032x')}")
-                    
-                    if input_data is not None:
-                        # Serialize for span attributes (OpenTelemetry only accepts primitives or JSON strings)
-                        serialized_input = _serialize_for_span(input_data)
-                        span.set_attribute("input", serialized_input)
-                    
-                    try:
-                        # Call the function within the span context
-                        trace_id = format(span.get_span_context().trace_id, "032x")
-                        logger.debug(f"do traceable stuff {fn_name} {trace_id}")
-                        
-                        result = await fn(*args, **kwargs)
-                        
-                        # Prepare output
-                        output_data = result
-                        if filter_output:
-                            output_data = filter_output(output_data)                    
-                        if ignore_output and isinstance(output_data, dict):
-                            # Make a copy of output_data to avoid modifying the original
-                            output_data = output_data.copy()
-                            for key in ignore_output:
-                                if key in output_data:
-                                    del output_data[key]
-                        
-                        span.set_attribute("output", _serialize_for_span(output_data))
-                        span.set_status(Status(StatusCode.OK))
-                        
-                        logger.debug(f"Span {fn_name} completed successfully, is_recording={span.is_recording()}")
-                        return result
-                    except Exception as exception:
-                        error = exception if isinstance(exception, Exception) else Exception(str(exception))
-                        span.record_exception(error)
-                        span.set_status(Status(StatusCode.ERROR, str(error)))
-                        raise
-                    finally:
-                        # Log when span context exits - span should be ended automatically by context manager
-                        logger.debug(f"Span {fn_name} context exiting, is_recording={span.is_recording()}")
+                input_data = _prepare_and_filter_input(args, kwargs, filter_input, ignore_input)
+                return await _execute_with_span_async(
+                    lambda: fn(*args, **kwargs),
+                    input_data
+                )
             
             async_traced_fn._is_traced = True
             logger.debug(f"Function {fn_name} is now traced (async)")
@@ -239,56 +487,11 @@ def WithTracing(
         else:
             @wraps(fn)
             def sync_traced_fn(*args, **kwargs):
-                # Prepare input
-                input_data = _prepare_input(args, kwargs)
-                if filter_input:
-                    input_data = filter_input(input_data)
-                if ignore_input and isinstance(input_data, dict):
-                    for key in ignore_input:
-                        if key in input_data:
-                            del input_data[key]
-                
-                # Use start_as_current_span to ensure span is recorded by BatchSpanProcessor
-                with tracer.start_as_current_span(fn_name) as span:
-                    # Check if span is recording - if not, spans won't be exported
-                    if not span.is_recording():
-                        logger.warning(f"Span {fn_name} is not recording - will not be exported")
-                        return fn(*args, **kwargs)
-                    
-                    logger.debug(f"Span {fn_name} is recording, trace_id={format(span.get_span_context().trace_id, '032x')}")
-                    
-                    if input_data is not None:
-                        # Serialize for span attributes (OpenTelemetry only accepts primitives or JSON strings)
-                        serialized_input = _serialize_for_span(input_data)
-                        span.set_attribute("input", serialized_input)
-                    
-                    try:
-                        # Call the function within the span context
-                        trace_id = format(span.get_span_context().trace_id, "032x")
-                        logger.debug(f"do traceable stuff {fn_name} {trace_id}")
-                        
-                        result = fn(*args, **kwargs)
-                        
-                        # Prepare output
-                        output_data = result
-                        if filter_output:
-                            output_data = filter_output(output_data)
-                        if ignore_output and isinstance(output_data, dict):
-                            # Make a copy of output_data to avoid modifying the original
-                            output_data = output_data.copy()
-                            for key in ignore_output:
-                                if key in output_data:
-                                    del output_data[key]
-                        
-                        span.set_attribute("output", _serialize_for_span(output_data))
-                        span.set_status(Status(StatusCode.OK))
-                        
-                        return result
-                    except Exception as exception:
-                        error = exception if isinstance(exception, Exception) else Exception(str(exception))
-                        span.record_exception(error)
-                        span.set_status(Status(StatusCode.ERROR, str(error)))
-                        raise
+                input_data = _prepare_and_filter_input(args, kwargs, filter_input, ignore_input)
+                return _execute_with_span_sync(
+                    lambda: fn(*args, **kwargs),
+                    input_data
+                )
             
             sync_traced_fn._is_traced = True
             logger.debug(f"Function {fn_name} is now traced (sync)")
@@ -328,3 +531,13 @@ def get_active_span() -> Optional[trace.Span]:
     """Get the currently active span."""
     return trace.get_current_span()
 
+def get_provider() -> Optional[TracerProvider]:
+    """Get the tracer provider for advanced usage."""
+    client = get_client()
+    return client.get("provider")
+
+def get_exporter() -> Optional[AIQASpanExporter]:
+    """Get the exporter for advanced usage."""
+    client = get_client()
+    return client.get("exporter")
+

{aiqa_client-0.1.6.dist-info → aiqa_client-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiqa-client
-Version: 0.1.6
+Version: 0.2.1
 Summary: OpenTelemetry-based Python client for tracing functions and sending traces to the AIQA server
 Author-email: AIQA <info@aiqa.dev>
 License: MIT

aiqa_client-0.2.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+aiqa/__init__.py,sha256=Co9t4kYAXI4WKhnTlIhIcQTeJJgFF0mzgmj0yhaS6p4,539
+aiqa/aiqa_exporter.py,sha256=aEXMfdUL2OILt9H4CRkpoi9EgOqr1UthyQFrimZoDFk,19200
+aiqa/client.py,sha256=1QSZhPdpRJilASuS7YtYlzcTNARY0O6lnQB7m2Jm-jA,1421
+aiqa/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aiqa/tracing.py,sha256=rtMXbcU13nQYepV-KAP5Sugui8Ox-eQCgksRp3VlwpM,20367
+aiqa_client-0.2.1.dist-info/licenses/LICENSE,sha256=kIzkzLuzG0HHaWYm4F4W5FeJ1Yxut3Ec6bhLWyw798A,1062
+aiqa_client-0.2.1.dist-info/METADATA,sha256=WgHjtG5pmyViDill6UnD3DjzE3mLl_ZLE-rE7x2ECak,3772
+aiqa_client-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiqa_client-0.2.1.dist-info/top_level.txt,sha256=nwcsuVVSuWu27iLxZd4n1evVzv1W6FVTrSnCXCc-NQs,5
+aiqa_client-0.2.1.dist-info/RECORD,,

aiqa_client-0.1.6.dist-info/RECORD

@@ -1,9 +0,0 @@
-aiqa/__init__.py,sha256=KXcAhHf_aZCgs6bn5Gw3IHccunqZzjbj8md0RuWSRAg,470
-aiqa/aiqa_exporter.py,sha256=vXyX6Q_iOjrDz3tCPOMXuBTQg7ocACdOOqzpkUqhy9g,19131
-aiqa/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aiqa/tracing.py,sha256=mWYIZ2Pla91oUY5a6OXOJWUR2eYtjoQkYPaJdBTpho8,13522
-aiqa_client-0.1.6.dist-info/licenses/LICENSE,sha256=kIzkzLuzG0HHaWYm4F4W5FeJ1Yxut3Ec6bhLWyw798A,1062
-aiqa_client-0.1.6.dist-info/METADATA,sha256=Yu-H7t101WTN5rdwJl8-7AAVemL9hHZVxSGjZifurKk,3772
-aiqa_client-0.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiqa_client-0.1.6.dist-info/top_level.txt,sha256=nwcsuVVSuWu27iLxZd4n1evVzv1W6FVTrSnCXCc-NQs,5
-aiqa_client-0.1.6.dist-info/RECORD,,