Metadata-Version: 2.1
Name: petit_type_system
Version: 0.1.10
Summary: Backend to handle type conversion from python to another language
Home-page: https://github.com/Plawn/petit_type_system
Author: Plawn
Author-email: plawn.yay@gmail.com
License: apache-2.0
Description: # Petit Type System
        
        
        This library is meant to be used as a backend to implement type exporter from python to another language.
        
        In order to use it, you are supposed to implement the different handlers for the types you want to export.
        
        Petit-ts is based on it, and is able to export any of current python types.
        
        Petit-java is currently under development and will make the export of python types to Java available
        
        The next step will be to build an GraphQL exporter
        
        ## Where to start ?
        
        The libs works by using a store which has handlers for each type of data. To create a new type of store, you have to use `create_store_class`, this will return a factory, which can later be used to create an actual store, which will hold all of the informations of your different types.
        
        Example:
        
        ```python
        ts_raw_default_types: List[Tuple[Any, str]] = [
            (bool, "boolean"),
            (None, "void"),
            (NoneType, "undefined"),
        
            (null, "null"),
            (undefined, "undefined"),
        
            (int, "number /*int*/"),
            (float, "number /*float*/"),
        
            (str, "string"),
            (dict, "object"),
            (list, "any[]"),
        
            (List[Any], "any[]"),
            (List, "any[]"),
            (List[int], "number[]"),
            (List[str], "string[]"),
        
            # any's
            (object, "any"),
            (Any, "any"),
        ]
        
        
        # TS-specifics
        ts_export_token = 'export'
        
        ts_class_handlers: List[Type[ClassHandler]] = [
            TSEnumHandler,
            TSDataclassHandler,
        ]
        
        ts_basic_handlers: List[Type[BasicHandler]] = [
            TSUnionHandler,
            TSLiteralHandler,
            TSArrayHandler,
            TSMappingHandler,
            TSTupleHandler,
        ]
        
        TSTypeStore = create_store_class(
            ts_export_token,
            struct_handler=TSStructHandler,
            basic_handlers=ts_basic_handlers,
            class_handlers=ts_class_handlers,
            basic_types=ts_raw_default_types,
        )
        ```
        
        This is an example taken from petit-ts
        
        We have 3 types of handlers:
        
        - BasicHandler
        - ClassHandler
        - StructHandler
        
        ### BasicHandler
        
        A `BasicHandler` implements two methods:
        
        #### should_handle(cls: Any) -> bool
        
        This functions returns wether this Handler should actually handle the supplied object
        
        #### build(cls: Any) -> Tuple[Optional[str], str]
        
        This function builds the representation of your type in the target language, most of the time it will use the `store.get_repr(value)` expression.
        
        It returns a Tuple[Optional[str], str] where the first value, is the name the exported type. In some langague you can return `None` and the type will be inlined.
        
        For example Typescript supports it but Java doesn't.
        
        The second value is the actual representation.
        
        ### ClassHandler
        
        A `ClassHandler` implements 3 methods:
        
        #### is_mapping() -> bool
        
        This function tells the library if it should use the `StructRenderer` on the returned data or just use the result a the representation directly
        
        For example, the `DataclassHandler` and the `PydanticHandler` use it in order to reduce the amount of code. 
        
        
        #### should_handle
        
        Like for the BaseHandler this method returns wether the handler should handle the supplied object.
        
        #### build
        
        This function returns, a string representation or a dict depending on if it's a mapping or not
        
        ### StructHandler
        
        This handler implements the process of making structs for the target language.
        
        A `StructHandler` implements 2 methods:
        
        ### make_struct
        
        This methods returns a string representation of a given dict, or dict-like object.
        
        ### make_struct_inline
        
        This does the same as the previous function but it does it inline.
        
        For example, Typescript supports it but Java doesn't.
        
        If you don't want to support this option or if the target language doesn't support it, you don't have to do anything.
        
        ### BasicTypes
        
        We have the basic types and their string representation.
        
        ### Export token
        
        For now we use an export token, it is used in order to export a type from a given class/module.
        
        
        ## Todo
        
        Update the part where the generic classes are handled
        
Platform: UNKNOWN
Requires-Python: >=3.8
Description-Content-Type: text/markdown
