tywrap-ir 0.1.2__tar.gz

tywrap_ir-0.1.2/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: tywrap-ir
+Version: 0.1.2
+Summary: Python IR extractor for tywrap: emits versioned JSON IR for Python modules
+Author: tywrap contributors
+Maintainer: tywrap contributors
+License: MIT
+Project-URL: Homepage, https://github.com/bbopen/tywrap
+Project-URL: Repository, https://github.com/bbopen/tywrap
+Project-URL: Documentation, https://github.com/bbopen/tywrap#readme
+Project-URL: Issues, https://github.com/bbopen/tywrap/issues
+Keywords: tywrap,typescript,python,bridge,code-generation,ast,ir
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# tywrap-ir
+
+[![PyPI version](https://img.shields.io/pypi/v/tywrap-ir.svg)](https://pypi.org/project/tywrap-ir/)
+[![Python versions](https://img.shields.io/pypi/pyversions/tywrap-ir.svg)](https://pypi.org/project/tywrap-ir/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Python IR extractor for [tywrap](https://github.com/bbopen/tywrap). Emits versioned JSON IR for Python modules using inspect/typing/importlib.
+
+## Installation
+
+```bash
+pip install tywrap-ir
+```
+
+## Usage
+
+```bash
+# Extract IR for a module
+python -m tywrap_ir --module math
+
+# Or using the CLI
+tywrap-ir --module math
+
+# Output to file
+tywrap-ir --module pandas --output pandas_ir.json
+```
+
+## What is this?
+
+This package is the Python component of tywrap, a TypeScript wrapper generator for Python libraries. It analyzes Python modules and extracts type information into a JSON intermediate representation (IR) that tywrap uses to generate TypeScript bindings.
+
+You typically don't need to use this package directly - the `tywrap` npm package invokes it automatically during code generation.
+
+## Requirements
+
+- Python 3.10+
+
+## Related
+
+- [tywrap](https://www.npmjs.com/package/tywrap) - The main TypeScript package
+- [GitHub](https://github.com/bbopen/tywrap) - Source code and issues
+
+## License
+
+MIT

tywrap_ir-0.1.2/README.md

@@ -0,0 +1,45 @@
+# tywrap-ir
+
+[![PyPI version](https://img.shields.io/pypi/v/tywrap-ir.svg)](https://pypi.org/project/tywrap-ir/)
+[![Python versions](https://img.shields.io/pypi/pyversions/tywrap-ir.svg)](https://pypi.org/project/tywrap-ir/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Python IR extractor for [tywrap](https://github.com/bbopen/tywrap). Emits versioned JSON IR for Python modules using inspect/typing/importlib.
+
+## Installation
+
+```bash
+pip install tywrap-ir
+```
+
+## Usage
+
+```bash
+# Extract IR for a module
+python -m tywrap_ir --module math
+
+# Or using the CLI
+tywrap-ir --module math
+
+# Output to file
+tywrap-ir --module pandas --output pandas_ir.json
+```
+
+## What is this?
+
+This package is the Python component of tywrap, a TypeScript wrapper generator for Python libraries. It analyzes Python modules and extracts type information into a JSON intermediate representation (IR) that tywrap uses to generate TypeScript bindings.
+
+You typically don't need to use this package directly - the `tywrap` npm package invokes it automatically during code generation.
+
+## Requirements
+
+- Python 3.10+
+
+## Related
+
+- [tywrap](https://www.npmjs.com/package/tywrap) - The main TypeScript package
+- [GitHub](https://github.com/bbopen/tywrap) - Source code and issues
+
+## License
+
+MIT

tywrap_ir-0.1.2/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tywrap-ir"
+version = "0.1.2"
+description = "Python IR extractor for tywrap: emits versioned JSON IR for Python modules"
+readme = "README.md"
+authors = [
+  { name = "tywrap contributors" }
+]
+maintainers = [
+  { name = "tywrap contributors" }
+]
+requires-python = ">=3.10"
+dependencies = []
+license = { text = "MIT" }
+keywords = ["tywrap", "typescript", "python", "bridge", "code-generation", "ast", "ir"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Software Development :: Code Generators",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Typing :: Typed",
+]
+
+[project.urls]
+Homepage = "https://github.com/bbopen/tywrap"
+Repository = "https://github.com/bbopen/tywrap"
+Documentation = "https://github.com/bbopen/tywrap#readme"
+Issues = "https://github.com/bbopen/tywrap/issues"
+
+[project.scripts]
+tywrap-ir = "tywrap_ir.__main__:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["tywrap_ir*"]

tywrap_ir-0.1.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tywrap_ir-0.1.2/tywrap_ir/__init__.py

@@ -0,0 +1,10 @@
+__all__ = [
+    "extract_module_ir",
+    "IR_VERSION",
+    "__version__",
+]
+
+__version__ = "0.1.2"
+IR_VERSION = "0.1.0"
+
+from .ir import extract_module_ir  # noqa: E402

tywrap_ir-0.1.2/tywrap_ir/__main__.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from .ir import emit_ir_json
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="tywrap IR extractor")
+    parser.add_argument("--module", help="Python module name, e.g. math or pandas")
+    parser.add_argument("--package", help="Python package name (alias of --module for now)")
+    parser.add_argument("--output", help="Write JSON IR to file instead of stdout")
+    parser.add_argument("--ir-version", default="0.1.0", help="IR schema version")
+    parser.add_argument("--include-private", action="store_true", help="Include private members (leading _)")
+    parser.add_argument("--no-pretty", action="store_true", help="Disable pretty JSON formatting")
+    args = parser.parse_args()
+
+    target = args.module or args.package
+    if not target:
+        sys.stderr.write("Error: --module or --package is required\n")
+        sys.exit(2)
+
+    try:
+        output = emit_ir_json(
+            target,
+            ir_version=args.ir_version,
+            include_private=args.include_private,
+            pretty=not args.no_pretty,
+        )
+        if args.output:
+            with open(args.output, "w", encoding="utf-8") as f:
+                f.write(output)
+        else:
+            sys.stdout.write(output + "\n")
+    except Exception as exc:  # pragma: no cover
+        sys.stderr.write(f"Error: {exc}\n")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

tywrap_ir-0.1.2/tywrap_ir/ir.py

@@ -0,0 +1,462 @@
+from __future__ import annotations
+
+import importlib
+import inspect
+import json
+import platform
+import sys
+from dataclasses import dataclass, asdict
+from typing import Any, Dict, List, Optional, get_type_hints
+import dataclasses as _dataclasses
+import typing
+
+try:
+    from importlib import metadata as importlib_metadata  # py3.8+
+except Exception:  # pragma: no cover
+    import importlib_metadata  # type: ignore
+
+
+@dataclass
+class IRParam:
+    name: str
+    kind: str
+    annotation: str | None
+    default: bool
+
+
+@dataclass
+class IRFunction:
+    name: str
+    qualname: str
+    docstring: Optional[str]
+    parameters: List[IRParam]
+    returns: Optional[str]
+    is_async: bool
+    is_generator: bool
+
+
+@dataclass
+class IRClass:
+    name: str
+    qualname: str
+    docstring: Optional[str]
+    bases: List[str]
+    methods: List[IRFunction]
+    typed_dict: bool
+    total: Optional[bool]
+    fields: List[IRParam]
+    is_protocol: bool
+    is_namedtuple: bool
+    is_dataclass: bool
+    is_pydantic: bool
+
+
+@dataclass
+class IRConstant:
+    name: str
+    annotation: str | None
+    value_repr: str | None
+    is_final: bool
+
+
+@dataclass
+class IRTypeAlias:
+    name: str
+    definition: str
+    is_generic: bool
+
+
+@dataclass
+class IRModule:
+    ir_version: str
+    module: str
+    functions: List[IRFunction]
+    classes: List[IRClass]
+    constants: List[IRConstant]
+    type_aliases: List[IRTypeAlias]
+    metadata: Dict[str, Any]
+    warnings: List[str]
+
+
+# Minimal, stringified annotation representation
+
+def _stringify_annotation(annotation: Any) -> Optional[str]:
+    if annotation is inspect._empty:  # type: ignore[attr-defined]
+        return None
+    try:
+        # Handle forward references more elegantly
+        str_repr = str(annotation)
+        
+        # Clean up class references to show just the class name
+        if str_repr.startswith("<class '") and str_repr.endswith("'>"):
+            # Extract class name from <class 'module.ClassName'>
+            class_path = str_repr[8:-2]  # Remove <class ' and '>
+            if '.' in class_path:
+                return class_path.split('.')[-1]  # Just the class name
+            return class_path
+        
+        return str_repr
+    except Exception:
+        return None
+
+
+def _param_kind_to_str(kind: inspect._ParameterKind) -> str:
+    mapping = {
+        inspect.Parameter.POSITIONAL_ONLY: "POSITIONAL_ONLY",
+        inspect.Parameter.POSITIONAL_OR_KEYWORD: "POSITIONAL_OR_KEYWORD",
+        inspect.Parameter.VAR_POSITIONAL: "VAR_POSITIONAL",
+        inspect.Parameter.KEYWORD_ONLY: "KEYWORD_ONLY",
+        inspect.Parameter.VAR_KEYWORD: "VAR_KEYWORD",
+    }
+    return mapping.get(kind, str(kind))
+
+
+def _extract_constants(module: Any, module_name: str, include_private: bool) -> List[IRConstant]:
+    """Extract module-level constants and Final variables."""
+    constants: List[IRConstant] = []
+    
+    # Check module annotations for type hints
+    annotations = getattr(module, '__annotations__', {})
+    
+    for name in dir(module):
+        if not include_private and name.startswith("_"):
+            continue
+            
+        try:
+            value = getattr(module, name)
+        except Exception:
+            continue
+            
+        # Skip functions, classes, modules, and other non-constant items
+        if (inspect.isfunction(value) or inspect.isclass(value) or 
+            inspect.ismodule(value) or callable(value)):
+            continue
+            
+        # Check if it's a constant (uppercase naming convention or Final)
+        is_constant = name.isupper() or name in annotations
+        
+        if is_constant:
+            annotation = annotations.get(name)
+            annotation_str = _stringify_annotation(annotation) if annotation else None
+            
+            # Check if it's Final
+            is_final = False
+            if annotation_str and ('Final[' in annotation_str or annotation_str == 'Final'):
+                is_final = True
+            
+            # Get string representation of value (truncated for large objects)
+            try:
+                value_repr = repr(value)
+                if len(value_repr) > 200:
+                    value_repr = value_repr[:197] + "..."
+            except Exception:
+                value_repr = "<unrepresentable>"
+            
+            constants.append(IRConstant(
+                name=name,
+                annotation=annotation_str,
+                value_repr=value_repr,
+                is_final=is_final
+            ))
+    
+    return constants
+
+
+def _extract_type_aliases(module: Any, module_name: str, include_private: bool) -> List[IRTypeAlias]:
+    """Extract type aliases from module."""
+    type_aliases: List[IRTypeAlias] = []
+    
+    # Check module annotations for type aliases
+    annotations = getattr(module, '__annotations__', {})
+    
+    for name, annotation in annotations.items():
+        if not include_private and name.startswith("_"):
+            continue
+            
+        try:
+            value = getattr(module, name, None)
+        except Exception:
+            continue
+            
+        # Type aliases are typically annotated but check for specific patterns
+        annotation_str = _stringify_annotation(annotation)
+        
+        # Check if it's a type alias (has TypeAlias annotation or follows patterns)
+        is_type_alias = (
+            annotation_str and ('TypeAlias' in annotation_str or 
+                              'typing.Union' in annotation_str or
+                              'typing.Optional' in annotation_str or
+                              'typing.List' in annotation_str or
+                              'typing.Dict' in annotation_str or
+                              '|' in annotation_str)  # Modern union syntax
+        )
+        
+        if is_type_alias:
+            # Check if it's generic (contains type parameters)
+            is_generic = bool(annotation_str and any(
+                marker in annotation_str for marker in ['[', '~', 'TypeVar', 'Generic']
+            ))
+            
+            type_aliases.append(IRTypeAlias(
+                name=name,
+                definition=annotation_str or str(annotation),
+                is_generic=is_generic
+            ))
+    
+    return type_aliases
+
+
+def _extract_function(obj: Any, qualname: str) -> Optional[IRFunction]:
+    try:
+        sig = inspect.signature(obj)
+    except Exception:
+        return None
+
+    # Use get_type_hints to resolve ForwardRefs where possible
+    try:
+        hints = get_type_hints(obj)
+    except Exception:
+        hints = {}
+
+    params: List[IRParam] = []
+    for name, p in sig.parameters.items():
+        ann = hints.get(name, p.annotation)
+        params.append(
+            IRParam(
+                name=name,
+                kind=_param_kind_to_str(p.kind),
+                annotation=_stringify_annotation(ann),
+                default=(p.default is not inspect._empty),
+            )
+        )
+
+    returns = hints.get("return", sig.return_annotation)
+    is_async = inspect.iscoroutinefunction(obj) or inspect.isasyncgenfunction(obj)
+    is_generator = inspect.isgeneratorfunction(obj)
+
+    return IRFunction(
+        name=getattr(obj, "__name__", qualname.split(".")[-1]),
+        qualname=qualname,
+        docstring=inspect.getdoc(obj),
+        parameters=params,
+        returns=_stringify_annotation(returns),
+        is_async=is_async,
+        is_generator=is_generator,
+    )
+
+
+def _extract_class(cls: type, module_name: str, include_private: bool) -> Optional[IRClass]:
+    name = getattr(cls, "__name__", None)
+    if not name:
+        return None
+    if not include_private and name.startswith("_"):
+        return None
+
+    bases = [b.__name__ for b in getattr(cls, "__bases__", []) if hasattr(b, "__name__")]
+
+    methods: List[IRFunction] = []
+    for meth_name, value in inspect.getmembers(
+        cls,
+        predicate=lambda x: inspect.isfunction(x) or inspect.ismethoddescriptor(x) or inspect.isbuiltin(x),
+    ):
+        if not include_private and meth_name.startswith("_"):
+            continue
+        fn = _extract_function(value, f"{module_name}.{cls.__name__}.{meth_name}")
+        if fn is not None:
+            methods.append(fn)
+
+    # TypedDict detection and fields
+    typed_dict = False
+    total: Optional[bool] = None
+    fields: List[IRParam] = []
+    try:
+        # Heuristic: TypedDict classes have __annotations__ and __total__
+        if hasattr(cls, "__annotations__") and hasattr(cls, "__total__"):
+            typed_dict = True
+            total = bool(getattr(cls, "__total__", True))
+            ann = get_type_hints(cls, include_extras=True) if hasattr(typing, "get_origin") else getattr(cls, "__annotations__", {})
+            for fname, ftype in ann.items():
+                text = _stringify_annotation(ftype)
+                # Determine optionality from NotRequired/Required wrappers if present
+                s = str(ftype)
+                is_not_required = "NotRequired[" in s or "typing.NotRequired[" in s
+                is_required = "Required[" in s or "typing.Required[" in s
+                optional_flag = is_not_required or (not is_required and total is False)
+                fields.append(IRParam(name=fname, kind="FIELD", annotation=text, default=optional_flag))
+    except Exception:
+        pass
+
+    # Protocol detection
+    is_protocol = False
+    try:
+        for b in getattr(cls, "__mro__", []):
+            if getattr(b, "__name__", None) == "Protocol":
+                is_protocol = True
+                break
+    except Exception:
+        is_protocol = False
+
+    # NamedTuple detection
+    is_namedtuple = hasattr(cls, "_fields") and isinstance(getattr(cls, "_fields", None), (list, tuple))
+    if is_namedtuple and not fields:
+        try:
+            ann = get_type_hints(cls, include_extras=True) if hasattr(typing, "get_origin") else getattr(cls, "__annotations__", {})
+            for fname in getattr(cls, "_fields", []):
+                ftype = ann.get(fname, None)
+                fields.append(IRParam(name=str(fname), kind="FIELD", annotation=_stringify_annotation(ftype), default=False))
+        except Exception:
+            pass
+
+    # Dataclass detection
+    is_dataclass = False
+    try:
+        is_dataclass = _dataclasses.is_dataclass(cls)
+    except Exception:
+        is_dataclass = False
+    if is_dataclass and not fields:
+        try:
+            for f in _dataclasses.fields(cls):  # type: ignore[attr-defined]
+                defaulted = not (f.default is _dataclasses.MISSING and f.default_factory is _dataclasses.MISSING)  # type: ignore[attr-defined]
+                fields.append(IRParam(name=f.name, kind="FIELD", annotation=_stringify_annotation(f.type), default=defaulted))
+        except Exception:
+            pass
+
+    # Pydantic detection
+    is_pydantic = False
+    try:
+        import pydantic
+
+        try:
+            base = pydantic.BaseModel  # type: ignore[attr-defined]
+        except Exception:
+            base = None
+        if base is not None:
+            try:
+                is_pydantic = issubclass(cls, base)
+            except Exception:
+                is_pydantic = False
+    except Exception:
+        is_pydantic = False
+    if is_pydantic and not fields:
+        try:
+            # v2
+            model_fields = getattr(cls, "model_fields", None)
+            if isinstance(model_fields, dict):
+                for fname, finfo in model_fields.items():
+                    ann = getattr(finfo, "annotation", None)
+                    required = getattr(finfo, "is_required", False)
+                    fields.append(IRParam(name=str(fname), kind="FIELD", annotation=_stringify_annotation(ann), default=(not required)))
+            else:
+                # v1
+                __fields__ = getattr(cls, "__fields__", None)
+                if isinstance(__fields__, dict):
+                    for fname, finfo in __fields__.items():
+                        ann = getattr(finfo, "type_", None)
+                        required = getattr(finfo, "required", False)
+                        fields.append(IRParam(name=str(fname), kind="FIELD", annotation=_stringify_annotation(ann), default=(not required)))
+        except Exception:
+            pass
+
+    return IRClass(
+        name=name,
+        qualname=f"{module_name}.{name}",
+        docstring=inspect.getdoc(cls),
+        bases=bases,
+        methods=methods,
+        typed_dict=typed_dict,
+        total=total,
+        fields=fields,
+        is_protocol=is_protocol,
+        is_namedtuple=is_namedtuple,
+        is_dataclass=is_dataclass,
+        is_pydantic=is_pydantic,
+    )
+
+
+def _collect_metadata(module_name: str, ir_version: str) -> Dict[str, Any]:
+    py_version = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+    plat = platform.platform()
+
+    pkg_root = module_name.split(".")[0]
+    version: Optional[str]
+    try:
+        version = importlib_metadata.version(pkg_root)
+    except Exception:
+        try:
+            mod = importlib.import_module(pkg_root)
+            version = getattr(mod, "__version__", None)
+        except Exception:
+            version = None
+
+    cache_key = f"{module_name}@{version or 'unknown'}|py{py_version}|ir{ir_version}"
+    return {
+        "python_version": py_version,
+        "platform": plat,
+        "package": pkg_root,
+        "package_version": version,
+        "cache_key": cache_key,
+    }
+
+
+def extract_module_ir(
+    module_name: str,
+    *,
+    ir_version: str = "0.1.0",
+    include_private: bool = False,
+) -> Dict[str, Any]:
+    """
+    Extract a minimal IR for a Python module: top-level callables with signature info.
+    """
+    module = importlib.import_module(module_name)
+
+    functions: List[IRFunction] = []
+    classes: List[IRClass] = []
+    warnings: List[str] = []
+    
+    # Extract constants and type aliases
+    constants = _extract_constants(module, module_name, include_private)
+    type_aliases = _extract_type_aliases(module, module_name, include_private)
+
+    for name in dir(module):
+        try:
+            value = getattr(module, name)
+        except Exception:
+            continue
+        if not include_private and name.startswith("_"):
+            continue
+        # Include plain functions and builtins (e.g., math.sqrt)
+        if inspect.isfunction(value) or inspect.isbuiltin(value):
+            fn = _extract_function(value, f"{module_name}.{name}")
+            if fn is not None:
+                functions.append(fn)
+        # Include classes defined in this module
+        if inspect.isclass(value) and getattr(value, "__module__", None) == module.__name__:
+            cls_ir = _extract_class(value, module_name, include_private)
+            if cls_ir is not None:
+                classes.append(cls_ir)
+
+    ir = IRModule(
+        ir_version=ir_version,
+        module=module_name,
+        functions=functions,
+        classes=classes,
+        constants=constants,
+        type_aliases=type_aliases,
+        metadata=_collect_metadata(module_name, ir_version),
+        warnings=warnings,
+    )
+    # Return as plain dicts ready for JSON emitting
+    return asdict(ir)
+
+def emit_ir_json(
+    module_name: str,
+    *,
+    ir_version: str = "0.1.0",
+    include_private: bool = False,
+    pretty: bool = True,
+) -> str:
+    return json.dumps(
+        extract_module_ir(module_name, ir_version=ir_version, include_private=include_private),
+        ensure_ascii=False,
+        indent=2 if pretty else None,
+    )

tywrap_ir-0.1.2/tywrap_ir/optimized_ir.py

@@ -0,0 +1,544 @@
+"""
+Optimized IR Extraction for tywrap
+High-performance Python module introspection with caching and parallel processing
+"""
+
+from __future__ import annotations
+
+import sys
+import time
+import threading
+import concurrent.futures
+from functools import lru_cache, wraps
+from typing import Dict, List, Any, Optional, Set, Callable
+import weakref
+import gc
+from dataclasses import dataclass, asdict
+
+# Reuse existing IR classes from ir.py
+from .ir import (
+    IRParam, IRFunction, IRClass, IRConstant, IRTypeAlias, IRModule,
+    _stringify_annotation, _param_kind_to_str, _extract_function, _extract_class,
+    _extract_constants, _extract_type_aliases, _collect_metadata
+)
+
+
+class PerformanceTimer:
+    """High-precision performance timer for profiling"""
+    
+    def __init__(self, name: str = ""):
+        self.name = name
+        self.start_time = 0.0
+        self.end_time = 0.0
+        
+    def __enter__(self):
+        self.start_time = time.perf_counter()
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.end_time = time.perf_counter()
+        duration = self.duration
+        print(f"⚡ {self.name}: {duration:.2f}ms", file=sys.stderr)
+    
+    @property
+    def duration(self) -> float:
+        """Duration in milliseconds"""
+        return (self.end_time - self.start_time) * 1000
+
+
+@dataclass
+class ExtractionStats:
+    """Statistics about IR extraction performance"""
+    total_time: float
+    functions_extracted: int
+    classes_extracted: int
+    constants_extracted: int
+    type_aliases_extracted: int
+    cache_hits: int
+    cache_misses: int
+    memory_peak: int  # bytes
+
+
+class IRCache:
+    """Intelligent caching for IR extraction results"""
+    
+    def __init__(self, max_size: int = 1000):
+        self.max_size = max_size
+        self._cache: Dict[str, Any] = {}
+        self._access_times: Dict[str, float] = {}
+        self._lock = threading.RLock()
+        self.hits = 0
+        self.misses = 0
+    
+    def _make_key(self, *args) -> str:
+        """Create cache key from arguments"""
+        return "|".join(str(arg) for arg in args)
+    
+    def get(self, key: str) -> Optional[Any]:
+        """Get item from cache"""
+        with self._lock:
+            if key in self._cache:
+                self._access_times[key] = time.time()
+                self.hits += 1
+                return self._cache[key]
+            
+            self.misses += 1
+            return None
+    
+    def set(self, key: str, value: Any) -> None:
+        """Set item in cache with LRU eviction"""
+        with self._lock:
+            # Evict oldest items if at capacity
+            if len(self._cache) >= self.max_size and key not in self._cache:
+                oldest_key = min(self._access_times.keys(), key=lambda k: self._access_times[k])
+                del self._cache[oldest_key]
+                del self._access_times[oldest_key]
+            
+            self._cache[key] = value
+            self._access_times[key] = time.time()
+    
+    def cached_function(self, func: Callable) -> Callable:
+        """Decorator for caching function results"""
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            # Create cache key from function name and arguments
+            key_parts = [func.__name__] + list(args) + [f"{k}={v}" for k, v in sorted(kwargs.items())]
+            key = self._make_key(*key_parts)
+            
+            result = self.get(key)
+            if result is not None:
+                return result
+            
+            result = func(*args, **kwargs)
+            self.set(key, result)
+            return result
+        
+        return wrapper
+    
+    def clear(self) -> None:
+        """Clear all cache entries"""
+        with self._lock:
+            self._cache.clear()
+            self._access_times.clear()
+            self.hits = 0
+            self.misses = 0
+    
+    def stats(self) -> Dict[str, Any]:
+        """Get cache statistics"""
+        with self._lock:
+            total_requests = self.hits + self.misses
+            hit_rate = self.hits / max(1, total_requests)
+            
+            return {
+                "size": len(self._cache),
+                "max_size": self.max_size,
+                "hits": self.hits,
+                "misses": self.misses,
+                "hit_rate": hit_rate,
+            }
+
+
+# Global cache instance
+_global_cache = IRCache()
+
+
+class OptimizedIRExtractor:
+    """High-performance IR extraction with optimization techniques"""
+    
+    def __init__(self, 
+                 enable_caching: bool = True,
+                 enable_parallel: bool = True,
+                 max_workers: int = 4):
+        self.enable_caching = enable_caching
+        self.enable_parallel = enable_parallel
+        self.max_workers = max_workers
+        self._cache = _global_cache if enable_caching else None
+        self._stats = ExtractionStats(0, 0, 0, 0, 0, 0, 0, 0)
+    
+    def extract_module_ir_optimized(self,
+                                   module_name: str,
+                                   *,
+                                   ir_version: str = "0.1.0",
+                                   include_private: bool = False) -> Dict[str, Any]:
+        """
+        Extract IR with performance optimizations
+        """
+        with PerformanceTimer(f"IR extraction for {module_name}"):
+            return self._extract_with_optimizations(module_name, ir_version, include_private)
+    
+    def _extract_with_optimizations(self, 
+                                   module_name: str,
+                                   ir_version: str,
+                                   include_private: bool) -> Dict[str, Any]:
+        """Internal optimized extraction"""
+        
+        # Try cache first
+        if self._cache:
+            cache_key = self._cache._make_key(module_name, ir_version, include_private)
+            cached_result = self._cache.get(cache_key)
+            if cached_result is not None:
+                print(f"🎯 Cache HIT for {module_name}", file=sys.stderr)
+                return cached_result
+        
+        # Import module with error handling
+        try:
+            import importlib
+            module = importlib.import_module(module_name)
+        except ImportError as e:
+            raise ImportError(f"Failed to import module {module_name}: {e}")
+        
+        # Extract components in parallel if enabled
+        if self.enable_parallel and self.max_workers > 1:
+            result = self._extract_parallel(module, module_name, ir_version, include_private)
+        else:
+            result = self._extract_sequential(module, module_name, ir_version, include_private)
+        
+        # Cache result
+        if self._cache:
+            self._cache.set(cache_key, result)
+        
+        return result
+    
+    def _extract_parallel(self,
+                         module: Any,
+                         module_name: str,
+                         ir_version: str,
+                         include_private: bool) -> Dict[str, Any]:
+        """Extract IR components in parallel"""
+        
+        with concurrent.futures.ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+            # Submit all extraction tasks
+            futures = {
+                'functions': executor.submit(self._extract_functions_optimized, module, module_name, include_private),
+                'classes': executor.submit(self._extract_classes_optimized, module, module_name, include_private),
+                'constants': executor.submit(self._extract_constants_optimized, module, module_name, include_private),
+                'type_aliases': executor.submit(self._extract_type_aliases_optimized, module, module_name, include_private),
+                'metadata': executor.submit(_collect_metadata, module_name, ir_version),
+            }
+            
+            # Collect results
+            results = {}
+            for key, future in futures.items():
+                try:
+                    results[key] = future.result(timeout=30)  # 30 second timeout
+                except concurrent.futures.TimeoutError:
+                    print(f"⚠️  Timeout extracting {key} from {module_name}", file=sys.stderr)
+                    results[key] = [] if key != 'metadata' else {}
+                except Exception as e:
+                    print(f"❌ Error extracting {key} from {module_name}: {e}", file=sys.stderr)
+                    results[key] = [] if key != 'metadata' else {}
+        
+        # Build IR module
+        ir_module = IRModule(
+            ir_version=ir_version,
+            module=module_name,
+            functions=results.get('functions', []),
+            classes=results.get('classes', []),
+            constants=results.get('constants', []),
+            type_aliases=results.get('type_aliases', []),
+            metadata=results.get('metadata', {}),
+            warnings=[]  # TODO: Collect warnings from parallel execution
+        )
+        
+        # Update statistics
+        self._stats.functions_extracted += len(ir_module.functions)
+        self._stats.classes_extracted += len(ir_module.classes)
+        self._stats.constants_extracted += len(ir_module.constants)
+        self._stats.type_aliases_extracted += len(ir_module.type_aliases)
+        
+        return asdict(ir_module)
+    
+    def _extract_sequential(self,
+                           module: Any,
+                           module_name: str,
+                           ir_version: str,
+                           include_private: bool) -> Dict[str, Any]:
+        """Extract IR components sequentially (fallback)"""
+        
+        with PerformanceTimer("Sequential extraction"):
+            functions = self._extract_functions_optimized(module, module_name, include_private)
+            classes = self._extract_classes_optimized(module, module_name, include_private)
+            constants = self._extract_constants_optimized(module, module_name, include_private)
+            type_aliases = self._extract_type_aliases_optimized(module, module_name, include_private)
+            metadata = _collect_metadata(module_name, ir_version)
+        
+        ir_module = IRModule(
+            ir_version=ir_version,
+            module=module_name,
+            functions=functions,
+            classes=classes,
+            constants=constants,
+            type_aliases=type_aliases,
+            metadata=metadata,
+            warnings=[]
+        )
+        
+        return asdict(ir_module)
+    
+    @lru_cache(maxsize=128)
+    def _get_module_members(self, module_name: str) -> List[str]:
+        """Cached module member listing"""
+        import importlib
+        module = importlib.import_module(module_name)
+        return dir(module)
+    
+    def _extract_functions_optimized(self,
+                                   module: Any,
+                                   module_name: str,
+                                   include_private: bool) -> List[IRFunction]:
+        """Optimized function extraction"""
+        import inspect
+        
+        functions: List[IRFunction] = []
+        members = self._get_module_members(module_name)
+        
+        # Pre-filter members to reduce attribute access
+        function_names = []
+        for name in members:
+            if not include_private and name.startswith("_"):
+                continue
+            
+            try:
+                value = getattr(module, name, None)
+                if inspect.isfunction(value) or inspect.isbuiltin(value):
+                    function_names.append(name)
+            except (AttributeError, ImportError):
+                continue
+        
+        # Extract functions with caching
+        for name in function_names:
+            try:
+                value = getattr(module, name)
+                if self._cache:
+                    cached_func = self._cache.cached_function(_extract_function)
+                    func_ir = cached_func(value, f"{module_name}.{name}")
+                else:
+                    func_ir = _extract_function(value, f"{module_name}.{name}")
+                
+                if func_ir is not None:
+                    functions.append(func_ir)
+            except Exception as e:
+                print(f"⚠️  Error extracting function {name}: {e}", file=sys.stderr)
+                continue
+        
+        return functions
+    
+    def _extract_classes_optimized(self,
+                                  module: Any,
+                                  module_name: str,
+                                  include_private: bool) -> List[IRClass]:
+        """Optimized class extraction"""
+        import inspect
+        
+        classes: List[IRClass] = []
+        members = self._get_module_members(module_name)
+        
+        # Pre-filter for classes defined in this module
+        class_names = []
+        for name in members:
+            if not include_private and name.startswith("_"):
+                continue
+            
+            try:
+                value = getattr(module, name, None)
+                if (inspect.isclass(value) and 
+                    getattr(value, "__module__", None) == module.__name__):
+                    class_names.append(name)
+            except (AttributeError, ImportError):
+                continue
+        
+        # Extract classes with caching
+        for name in class_names:
+            try:
+                value = getattr(module, name)
+                if self._cache:
+                    cached_class = self._cache.cached_function(_extract_class)
+                    class_ir = cached_class(value, module_name, include_private)
+                else:
+                    class_ir = _extract_class(value, module_name, include_private)
+                
+                if class_ir is not None:
+                    classes.append(class_ir)
+            except Exception as e:
+                print(f"⚠️  Error extracting class {name}: {e}", file=sys.stderr)
+                continue
+        
+        return classes
+    
+    def _extract_constants_optimized(self,
+                                    module: Any,
+                                    module_name: str,
+                                    include_private: bool) -> List[IRConstant]:
+        """Optimized constant extraction with caching"""
+        if self._cache:
+            cached_constants = self._cache.cached_function(_extract_constants)
+            return cached_constants(module, module_name, include_private)
+        else:
+            return _extract_constants(module, module_name, include_private)
+    
+    def _extract_type_aliases_optimized(self,
+                                       module: Any,
+                                       module_name: str,
+                                       include_private: bool) -> List[IRTypeAlias]:
+        """Optimized type alias extraction with caching"""
+        if self._cache:
+            cached_aliases = self._cache.cached_function(_extract_type_aliases)
+            return cached_aliases(module, module_name, include_private)
+        else:
+            return _extract_type_aliases(module, module_name, include_private)
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get extraction statistics"""
+        stats_dict = asdict(self._stats)
+        if self._cache:
+            stats_dict["cache"] = self._cache.stats()
+        return stats_dict
+    
+    def clear_cache(self) -> None:
+        """Clear extraction cache"""
+        if self._cache:
+            self._cache.clear()
+
+
+# Global optimized extractor instance
+_global_extractor = OptimizedIRExtractor()
+
+
+def extract_module_ir_optimized(module_name: str,
+                                *,
+                                ir_version: str = "0.1.0",
+                                include_private: bool = False,
+                                enable_caching: bool = True,
+                                enable_parallel: bool = True) -> Dict[str, Any]:
+    """
+    Optimized IR extraction with caching and parallel processing
+    
+    Args:
+        module_name: Name of the module to extract
+        ir_version: IR format version
+        include_private: Include private members
+        enable_caching: Enable result caching
+        enable_parallel: Enable parallel extraction
+    
+    Returns:
+        Dictionary containing the IR module data
+    """
+    
+    # Configure extractor if needed
+    if not enable_caching and _global_extractor.enable_caching:
+        _global_extractor._cache = None
+        _global_extractor.enable_caching = False
+    
+    if not enable_parallel and _global_extractor.enable_parallel:
+        _global_extractor.enable_parallel = False
+    
+    return _global_extractor.extract_module_ir_optimized(
+        module_name,
+        ir_version=ir_version,
+        include_private=include_private
+    )
+
+
+def benchmark_ir_extraction(module_names: List[str],
+                           iterations: int = 3,
+                           enable_optimizations: bool = True) -> Dict[str, Any]:
+    """
+    Benchmark IR extraction performance
+    
+    Args:
+        module_names: List of module names to benchmark
+        iterations: Number of iterations per module
+        enable_optimizations: Whether to enable optimizations
+    
+    Returns:
+        Benchmark results
+    """
+    
+    results = {
+        "modules": {},
+        "summary": {
+            "total_modules": len(module_names),
+            "iterations": iterations,
+            "optimizations_enabled": enable_optimizations,
+        }
+    }
+    
+    extractor = OptimizedIRExtractor(
+        enable_caching=enable_optimizations,
+        enable_parallel=enable_optimizations
+    )
+    
+    for module_name in module_names:
+        module_times = []
+        module_results = []
+        
+        for i in range(iterations):
+            if i == 0 or not enable_optimizations:
+                # Clear cache for first iteration or when optimizations disabled
+                extractor.clear_cache()
+                gc.collect()  # Force garbage collection
+            
+            start_time = time.perf_counter()
+            try:
+                result = extractor.extract_module_ir_optimized(module_name)
+                module_results.append(result)
+                end_time = time.perf_counter()
+                duration = (end_time - start_time) * 1000  # milliseconds
+                module_times.append(duration)
+                
+                print(f"📊 {module_name} iteration {i+1}: {duration:.2f}ms", file=sys.stderr)
+                
+            except Exception as e:
+                print(f"❌ Error benchmarking {module_name}: {e}", file=sys.stderr)
+                continue
+        
+        if module_times:
+            results["modules"][module_name] = {
+                "times": module_times,
+                "min_time": min(module_times),
+                "max_time": max(module_times),
+                "avg_time": sum(module_times) / len(module_times),
+                "speedup": module_times[0] / min(module_times) if len(module_times) > 1 else 1.0,
+                "functions_count": len(module_results[-1]["functions"]) if module_results else 0,
+                "classes_count": len(module_results[-1]["classes"]) if module_results else 0,
+            }
+    
+    # Overall statistics
+    all_times = [time for module_data in results["modules"].values() for time in module_data["times"]]
+    if all_times:
+        results["summary"].update({
+            "total_extractions": len(all_times),
+            "min_time": min(all_times),
+            "max_time": max(all_times),
+            "avg_time": sum(all_times) / len(all_times),
+            "total_time": sum(all_times),
+        })
+    
+    # Cache statistics
+    cache_stats = extractor.get_stats()
+    results["cache_stats"] = cache_stats
+    
+    return results
+
+
+if __name__ == "__main__":
+    import json
+    
+    # Example usage and benchmarking
+    test_modules = ["math", "json", "os", "sys", "time"]
+    
+    print("🚀 Benchmarking optimized IR extraction", file=sys.stderr)
+    
+    # Benchmark with optimizations
+    optimized_results = benchmark_ir_extraction(
+        test_modules, 
+        iterations=3, 
+        enable_optimizations=True
+    )
+    
+    print("\n📈 Benchmark Results (Optimized):", file=sys.stderr)
+    for module, data in optimized_results["modules"].items():
+        print(f"  {module}: {data['avg_time']:.2f}ms avg, {data['speedup']:.2f}x speedup", file=sys.stderr)
+    
+    # Output results as JSON for analysis
+    print(json.dumps(optimized_results, indent=2))

tywrap_ir-0.1.2/tywrap_ir.egg-info/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: tywrap-ir
+Version: 0.1.2
+Summary: Python IR extractor for tywrap: emits versioned JSON IR for Python modules
+Author: tywrap contributors
+Maintainer: tywrap contributors
+License: MIT
+Project-URL: Homepage, https://github.com/bbopen/tywrap
+Project-URL: Repository, https://github.com/bbopen/tywrap
+Project-URL: Documentation, https://github.com/bbopen/tywrap#readme
+Project-URL: Issues, https://github.com/bbopen/tywrap/issues
+Keywords: tywrap,typescript,python,bridge,code-generation,ast,ir
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# tywrap-ir
+
+[![PyPI version](https://img.shields.io/pypi/v/tywrap-ir.svg)](https://pypi.org/project/tywrap-ir/)
+[![Python versions](https://img.shields.io/pypi/pyversions/tywrap-ir.svg)](https://pypi.org/project/tywrap-ir/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Python IR extractor for [tywrap](https://github.com/bbopen/tywrap). Emits versioned JSON IR for Python modules using inspect/typing/importlib.
+
+## Installation
+
+```bash
+pip install tywrap-ir
+```
+
+## Usage
+
+```bash
+# Extract IR for a module
+python -m tywrap_ir --module math
+
+# Or using the CLI
+tywrap-ir --module math
+
+# Output to file
+tywrap-ir --module pandas --output pandas_ir.json
+```
+
+## What is this?
+
+This package is the Python component of tywrap, a TypeScript wrapper generator for Python libraries. It analyzes Python modules and extracts type information into a JSON intermediate representation (IR) that tywrap uses to generate TypeScript bindings.
+
+You typically don't need to use this package directly - the `tywrap` npm package invokes it automatically during code generation.
+
+## Requirements
+
+- Python 3.10+
+
+## Related
+
+- [tywrap](https://www.npmjs.com/package/tywrap) - The main TypeScript package
+- [GitHub](https://github.com/bbopen/tywrap) - Source code and issues
+
+## License
+
+MIT

tywrap_ir-0.1.2/tywrap_ir.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+tywrap_ir/__init__.py
+tywrap_ir/__main__.py
+tywrap_ir/ir.py
+tywrap_ir/optimized_ir.py
+tywrap_ir.egg-info/PKG-INFO
+tywrap_ir.egg-info/SOURCES.txt
+tywrap_ir.egg-info/dependency_links.txt
+tywrap_ir.egg-info/entry_points.txt
+tywrap_ir.egg-info/top_level.txt

tywrap_ir-0.1.2/tywrap_ir.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tywrap_ir-0.1.2/tywrap_ir.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tywrap-ir = tywrap_ir.__main__:main

tywrap_ir-0.1.2/tywrap_ir.egg-info/top_level.txt

@@ -0,0 +1 @@
+tywrap_ir