semvec/pypi-packages huggingface dataset:
pjsk-name-index 1.3.0
A library for indexing names from the game Project Sekai.

﻿# pjsk-name-index
> A library for indexing names from the game Project Sekai. (Python achieve)

# Index
## sekai_index() method
### Field Name Table
| Field       | Field Meaning                          |
| ------------ |---------------------------------------|
| full_name    | Team English Name/Role English Name    |
| full_name_cn | Team Chinese Name/Role Chinese Name    |
| simple_name  | Team Abbreviation/Role Abbreviation   |
| joke_name_cn | (For roles only) Role Nickname (Alias) |
| full_name_cn_official | (For teams only) Team Official Chinese Name |
The `pjsk-name-index` library provides the `sekai_index()` method, which can quickly index to other names of the corresponding role based on the provided parameters.
### Usage:
`sekai_index('Full Role Name/Full Team Name','Team Type (team or individual)').expected field`
### Example:
``` Python
from pjsk_name_index import sekai_index
print(sekai_index("knd","individual")['full_name_cn'])
// Output Result: > 宵崎奏
print(sekai_index("狮雨星绊","team")['full_name'])
// Output Result: > Leo/need
```
# License
MIT License
SibylSystem 0.0.25
Python Wrapper for the Sibyl System Antispam API for telegram
Requires Python: <4.0,>=3.7
Keywords: sibyl, wrapper, telegram, antispam, api

# SibylSystem-Py

>Python3 wrapper for the Sibyl System antispam API for telegram

## Installation

```
pip install sibylsystem
```

# Usage

```py
>>> from SibylSystem import PsychoPass
>>> c = PsychoPass("your token")

    SibylSystem-Py Copyright (C) 2024 Kaizoku
    This program comes with ABSOLUTELY NO WARRANTY.
    This is free software, and you are welcome to redistribute it
    under certain conditions.

>>> c.get_info(2037525377)
Ban(user_id=2037525377, banned=True, reason='Arcane', message='', ban_source_url='', date='2021-10-30T18:47:00.004137+05:30', banned_by=895373440, crime_coefficient=0)
```

# Docs ?

**Open the source and read the docstrings**
tools-frameworks 0.0.1
tools_frameworks component of pipelib
Requires Python: >=3.6

## Utility Frameworks

## CacheRefresh

Contract for cache refreshable

```python

class CacheRefreshable:

    def __init__(self, cache_key):
        self.cache_key = cache_key

    def destroy_cache(self, properties: dict):
        raise NotImplementedError

    def rebuild_cache(self, properties: dict):
        raise NotImplementedError

```

- Create an instance of cacheRefreshable
- give the instance to the cache api to watch
- the api will update the instance based on a cron 

```python
from tools_frameworks.cache_refresh.api import cache_api
hakuna_matata = SomeCacheRefreshable()
cache_api.watch(hakuna_matata)
```
 
## AsgardCron

- Helps run a scheduled thread based on a cron
- Returns an event once scheduled (the thread can be stopped by setting the event)

## grpc

Some helper utils for asyncio integrations and interceptors etc. (See ExponentialBackoff)

## Settings Store

- Utility for managing settings configs accross different environments
- Returns a cache refreshable settings instance
- We can also attach watchers with these settings files to react to the change in config (See `tools_frameworks.settings.store.SettingsStore#add_todo`)


```python
data = {'key': 'value'}
__update_s3_settings_file(data)
settings = settings_store.get_settings(self.s3_path)
assert 'new_key' not in settings.__dict__
# update remote settings file
data = {'new_key': 'new_value'}
self.__update_s3_settings_file(data)
self.__trigger_cache_refresh(properties={})
assert 'new_key' in settings.__dict__
``` 

## Slacker

Helpers for slack messaging

## Task

- Persistent store based execution framework
- Helps with basic book keeping
- Refer `tools_frameworks.tests.test_task.TaskStoreTest` for test cases


####Depends on `tools_commons, tools_config, tools_fs`
tools-config 0.0.1
tools_config component of pipelib
Requires Python: >=3.6

## Settings

Settings is the basic unit configuration shared accross our intuition stack

A setting file to be written in .yaml format

Example:

```yaml
base.path: 's3://spr-asgard/intuition'
k8s:
 namespace: 'default'
 cluster: 'intuition'
jenkins:
 url: 'https://qa4-build.sprinklr.com/jenkins'
 username: 'blahblah'
 password: 'blahblahblah'
fileSystem:
 s3.key:
 s3.secret:
persistenceConfig:
 mongoServerConfig:
    - name: 'INTUITION'
      host: '127.0.0.1'
      port: 27017
    - name: 'SPR_GLOBAL'
      host: '127.0.0.1'
      port: 27017
      alias: 'spr-global'
bert:
 ip: '10.11.94.110'
 port: 31555
 portOut: 31556
```

This settings file can be read into memory in the form of a dictionary using `Settings(file_path)` 

 
## Configuration Utilities

Right now will help provide the persistent configurations of various systems

- `serverConfiguration` for integration with `sprinklr.app` resources
- `verticalConfig` for determining the vertical given sprinklr context
- mongoConfiguration -> host ip/port for mongo server given alias

####Depends on `tools_commons, tools_fs`
tools-commons 0.0.1
tools_commons component of pipelib
Requires Python: >=3.6

## Commons

- `tools_commons` is intended to be a lite weight package for basic logic
- Does not depend on any other package

Before adding code here, please try to check if you could add your peice to 
- tools_fs
- tools_config
- tools_frameworks
- tools_io
- tools_messaging
- tools_nlp

```bash
Add more docs here
```
modified-porterstemmer 0.0.3
A modified Porter stemmer for verbs and other additional rules.
Requires Python: >=3.6

### What is stemming?

Stemming is a technique in Natural Language Processing that reduces various inflected forms of a word to a single invariant root form. This root form, known as the stem, may or may not be identical to the word's morphological root.

### What is it good for?

Stemming is highly useful in various applications, with query expansion in information retrieval being a prime example. For instance, in a search engine, if a user searches for "cat," it would be beneficial for the search to return documents containing the word "cats" as well. This won't happen unless both the query and the document index undergo stemming. Essentially, stemming reduces the specificity of queries, enabling the retrieval of more relevant results, though this involves a trade-off.

### What type of stemmer is this?

Porterstemmer_Modified is a suffix-stripping stemmer, which means it transforms words into stems by applying a predetermined sequence of changes to the word's suffix. Other stemmers may function differently, such as by using a lookup table to map inflected forms to their roots or by employing clustering techniques to group various forms around a central form. Each approach comes with its own set of pros and cons. Porterstemmer_Modified, specifically, is a modified version of the original Porter stemmer and includes more comprehensive rules for handling verbs and suffixes.

### How do I use it?

Using the Porterstemmer_Modified is straightforward. Simply import the stemmer, create an instance, and use it to stem words:

```python
from Porterstemmer_Modified import Porterstemmer_Modified
stemmer = Porterstemmer_Modified()
print(stemmer.stem('consistent'))
```

This process will convert the word 'consistent' to its stem form.
streamlit-router 0.1.8
werkzeug router for streamlit

# streamlit-router

## Install

```
pip install streamlit-router
```

![20240423141943](https://github.com/pragmatic-streamlit/streamlit-router/assets/932699/d59e78f3-7b1e-422a-be3b-6546a1040ca2)


## Example

```
import streamlit as st
from streamlit_router import StreamlitRouter


def index(router):
    st.text("fron page index")
    x = st.number_input("task id")
    if st.button("create task"):
        router.redirect(*router.build("create_task", {"x": x}))
    if st.button("cancel task"):
        router.redirect(*router.build("cancel_task", {"x": x}))
    if st.button("view task"):
        router.redirect(*router.build("view_task", {"x": x}))
    st.text("others on page index")


# variable router auto inject if as first params
def cancel_task(router, x):
    st.text(f"fron page cancel task x={x}")
    if st.button("back to index"):
        router.redirect(*router.build("index"))
    st.text("others on page cancel task")


# variable router auto inject if as first params
def create_task(x, router):
    st.text(f"fron page create task x={x}")
    if st.button("back to index"):
        router.redirect(*router.build("index"))
    st.text("others on page create task")


router = StreamlitRouter()
router.register(index, "/")
router.register(cancel_task, "/tasks/<int:x>", methods=["DELETE"])
router.register(create_task, "/tasks/<int:x>", methods=["POST"])


# deco also works
@router.map("/tasks/<int:x>")
def view_task(x):
    st.text(f"fron page view task x={x}")
    if st.button("back to index 2"):
        router.redirect(*router.build("index"))
    st.text("others on page view task")


router.serve()

```