semvec/pypi-packages huggingface dataset:
xiwang-cp-API 1.0.0.0
flask的API插件
Requires Python: >=3
Keywords: pack, api

# cp_API插件包 [![Version][version-badge]][version-link] ![MIT License][license-badge]

这是一个基于Flask的API模块插件包，它将服务于另一个项目common_platform，作为一个插件提供基础功能。


### 使用方式
```commandline
pip install cp_API
```
VSVNApplicationMonitoring 0.1.4
Used for integration with Application monitoring systems

To integrate application data into the Application Monitoring system, there are 2 functions:

    saveActiveUser: Save user information of the system every time they log in. The data passed includes:
        api_url = "http://localhost:5000"; // the API url of the Application Monitoring system
        data_user = {
            application_code: "app_1", // code of the application registered in the Application Monitoring system. Different applications have different codes
            user_name: "user_1" // username logged into the application
        }
    saveRequestCost: Store the cost information for each request. The data passed includes:
        api_url = "http://localhost:5000"; // the API url of the Application Monitoring system
        data_request = {
        service_code: "app_1", // code of the service registered in the Application Monitoring system. Different services have different codes
        cost: 0.5 // Cost for this request. Unit: dollars
        }
The return result when calling these functions has a statusCode of 200 if the data is stored successfully. Otherwise, please call again.
typing-as-t 1.0.1
LibCST codemod to transform typing imports
Requires Python: <4.0,>=3.9

# import-typing-as-t
LibCST Codemod to transform relative typing import (`from typing import...`) or generic typing import (`import typing`) and their refs to `import typing as t` + `t.` prefixed refs respectively.

# Install
* `pip install typing-as-t`
* Help: `typing-as-t --help`

## Examples

Before:
```python
    from typing import Callable, Optional, Generator, cast, Any

    a : Callable[..., Any] = lambda : "test"
    def func(c: Optional[int] = None) -> Generator:
        return cast(Generator, "blabla")
```

After:
```python
    import typing as t

    a : t.Callable[..., t.Any] = lambda : "test"
    def func(c: t.Optional[int] = None) -> t.Generator:
        return t.cast(t.Generator, "blabla")
```

---

Before:
```python
    from typing import cast, List, Dict, Any, Sequence, TypeAlias, Sequence, Generator

    float_list : TypeAlias = list[float]
    def func(z: float_list, c: Sequence[tuple[tuple[str, int], List[Dict[str, Any]]]] = None) -> Generator:
        return cast(Generator, "blabla")
```

After:
```python
    import typing as t

    float_list : t.TypeAlias = list[float]
    def func(z: float_list, c: t.Sequence[tuple[tuple[str, int], t.List[t.Dict[str, t.Any]]]] = None) -> t.Generator:
        return t.cast(t.Generator, "blabla")
```

---

Before:
```python
    import typing

    a : typing.Callable[..., typing.Any] = lambda : "test"
    def func(c: typing.Optional[int] = None) -> typing.Generator:
        return typing.cast(typing.Generator, "blabla")
```

After:
```python
    import typing as t

    a : t.Callable[..., t.Any] = lambda : "test"
    def func(c: t.Optional[int] = None) -> t.Generator:
        return t.cast(t.Generator, "blabla")
```
---

Before:
```python
from typing import Any, TYPE_CHECKING as TC
from typing import TypeAlias as TA

if TC:
    foo: dict[str, Any]

Vector: TA = list[float]
```

After:

```python
import typing as t

if t.TYPE_CHECKING:
    a: dict[str, t.Any]

Vector: t.TypeAlias = list[float]
```