semvec/pypi-packages huggingface dataset:
rSTSF 0.1.1
Fast, accurate and explainable time series classification through randomization
Requires Python: >=3.6

# Randomized-Supervised Time Series Forest (r-STSF)

The r-STSF is a Python package for fast, accurate, and explainable time series classification. It implements the methodology described in:

Cabello, N., Naghizade, E., Qi, J., et al. Fast, accurate and explainable time series classification through randomization. Data Min Knowl Disc (2023). [https://doi.org/10.1007/s10618-023-00978-w](https://doi.org/10.1007/s10618-023-00978-w)

An arXiv version of the paper is available here: [Fast, Accurate and Interpretable Time Series Classification Through Randomization](https://arxiv.org/abs/2105.14876) by Nestor Cabello, Elham Naghizade, Jianzhong Qi, and Lars Kulik.

## Installation

To install r-STSF, use pip:

```bash
pip install rSTSF
```

Ensure you have Python 3.6 or newer installed.


## Quick Start

To use r-STSF in your Python projects, import the rstsf classifier and initialize it as follows:

```bash
from rSTSF import rstsf

classifier = rstsf()
```

## Example Usage

Below is a simple example demonstrating how to train and predict with the r-STSF classifier:

```bash
# Assuming X_train, y_train, X_test are prepared data arrays
classifier.fit(X_train, y_train)
predictions = classifier.predict(X_test)
```

For more detailed examples, including how to prepare your data, refer to the Jupyter notebooks provided in the GitHub repository:


- [r-STSF Usage Example](https://github.com/stevcabello/r-STSF/blob/main/code/r-STSF.ipynb)
- [r-STSF Explainability Demo](https://github.com/stevcabello/r-STSF/blob/main/code/r-STSF_explainability_demo.ipynb)


## Features

- **Fast and Accurate**: Achieves state-of-the-art classification accuracy efficiently, suitable for large datasets or long time series.
- **Explainability**: Offers insights into classification decisions, aiding understanding and trust in predictions.
- **Flexible**: Utilizes multiple time series representations and aggregation functions to capture diverse patterns.


## License

r-STSF is licensed under the MIT License - see the LICENSE file for details.


## Citation
If you use r-STSF in your research, please cite the following paper:

```bibtext
@article{rSTSF2023,
  title={Fast, accurate and explainable time series classification through randomization},
  author={Cabello, Nestor and Naghizade, Elham and Qi, Jianzhong and Kulik, Lars},
  journal={Data Mining and Knowledge Discovery},
  year={2023},
  publisher={Springer}
}
wordtm 0.4.6
Topic Modeling Package
Keywords: word,scripture,topic modeling,visualization,low-code,pro-code,network analysis,BERTopic,LDA,NFM

wordtm 0.4.6
============

An NLP package for topic modeling on the Holy Scripture and other text
from low-code to pro-code

Installation
------------

.. code:: shell

   $ pip install wordtm

Usage
-----

``wordtm`` can be used to perform some NLP pre-processing tasks, text
exploration, including Chinese one, text visualization (word cloud), and
topic modeling (BERTopic, LDA and NMF) as follows:

.. code:: python

   from wordtm import meta, util, ta, tm, viz, pivot, quot

version Submodule
~~~~~~~~~~~~~~~~~

Provides some version information.

.. code:: python

   import wordtm
   print(wordtm.__version__)

meta Submodule
~~~~~~~~~~~~~~

Provides extracting source code of ``wordtm`` module and adding timing and code-showing features
to all functions of the module.

.. code:: python

   print(meta.get_module_info())

   print(meta.get_module_info(detailed=True))

   meta.addin_all()

quot Submodule
~~~~~~~~~~~~~~

Provides functions to extract the quotation source Scripture in OT based on the presribed NT Scripture.

.. code:: python

   cdf = util.load_word('cuv.csv')
   crom8 = util.extract2(cdf, 'Rom 8')
   
   quot.show_quot(crom8, lang='chi')

pivot Submodule
~~~~~~~~~~~~~~~

Provides a pivot table of the prescribed text.

.. code:: python

   cdf = util.load_word('cuv.csv')

   pivot.stat(cdf, chi=True)

ta Submodule
~~~~~~~~~~~~

Provides text analytics functions, including extracting the summarization of the prescribed text.

.. code:: python

   cdf = util.load_word('cuv.csv')
   crom8 = util.extract2(cdf, 'Rom 8')

   ta.summary(rom8, code=True)

tm Submodule
~~~~~~~~~~~~~

Provides text modeling functions, including LDA, NMF and BERTopics modeling.

.. code:: python

   lda = tm.lda_process("cuv.csv", chi=True, eval=True, timing=True)

   nmf = tm.nmf_process("cuv.csv", chi=True, eval=True, code=1)

   btm = tm.btm_process("cuv.csv", chi=True, cat='nt', eval=True)

util Submodule
~~~~~~~~~~~~~~

Provides loading text and text preprocessing functions.

.. code:: python

   df = util.load_word()
   cdf = util.load_word('cuv.csv')

   df.head()
   cdf.head()

   rom8 = util.extract2(df, 'Rom 8')
   crom8 = util.extract2(cdf, 'Rom 8')

viz Submodule
~~~~~~~~~~~~~

Wordcloud plotting from the prescribed text.

.. code:: python

   cdf = util.load_word('cuv.csv')

   viz.chi_wordcloud(cdf)

Contributing
------------

Interested in contributing? Check out the contributing guidelines.
Please note that this project is released with a Code of Conduct. By
contributing to this project, you agree to abide by its terms.

License
-------

``wordtm`` was created by Johnny Cheng. It is licensed under the terms
of the MIT license.

Credits
-------

``wordtm`` was created under the guidance of Jehovah, the Lord.
SOSPy 0.2.9
Python version of MATLAB SOSTOOLS, a toolbox for sum-of-squares optimization
Requires Python: >=3.10
Keywords: Sum of Square Optimization,SOSTOOLS

This package is a Python version of MATLAB TOOLBOX -- SOSTOOLS. 

This package contains functions based on **sympy** package. However, in case of a large number of decision variables, **sympy** may take a long time to parse the data.

Demos are in the folder [SOSPy_demos](https://github.com/zm2404/SOSPy/tree/main/SOSPy_demos/Sympy_demos).

### Updates in version 0.2.9:
- Add some data type annotations

### Updates in version 0.2.8:
- Fix bugs in **sossolve()**

### Updates in version 0.2.7:
- Fix bugs in **sosscssolver()**
- Add a function **remove_redundant_row()** to remove redundant rows in a non-full rank matrix, and get a full rank matrix
- Apply **remove_redundant_row()** to soscvxoptsolver() and sosscssolver(); now, they can solve demo 9
- Fix bugs in **sosgetsol()**; they can appropriately show the result

### Updates in version 0.2.6:
- Fix bugs in **soscvxoptsolver()** and **sosscssolver()**

### Updates in version 0.2.5:
- Allow changes of CVXOPT and SCS solver parameters through **options**

### Updates in version 0.2.4:
- Fix bugs in **sossolve()**

### Updates in version 0.2.3:
- Make SCS and CVXOPT independent from CVXPY. Now running SCS and CVXOPT doesn't need to go through CVXPY
- Adjust **sossolve()** accordingly
- Adjust **findsos()** accordingly


### Updates in version 0.2.2:
- Fix bugs in **sosmoseksolver()**


For technique issues, send to sospypython@gmail.com

Contributors: 
- James Anderson, email: james.anderson@columbia.edu
- Leonardo Felipe Toso, email: lt2879@columbia.edu
- Zhe Mo, email: zm2404@columbia.edu
OpenSTRAN 0.0.4
Open Source Structural Analysis with Python
Requires Python: >=3.8

# OpenSTRAN

OpenSTRAN - Open Source Structural Analysis with Python

## Installation
```
$ pip install OpenSTRAN
```

## Capabilities

OpenStruct allows for the creation of simple two-dimensional frame elements
and complex three-dimensional structures alike.

* 2D truss
* 3D truss
* 2D frame
* 3D space frame
* Interactive diagrams

## Limitations
* First order elastic analysis only.
* Shear and torsional deformations are not considered.

Second order inelastic analysis methods are currently under development.


## Example
Simply supported beam subject to a point load.
```python
from OpenSTRAN.model import Model

simpleBeam = Model()

N1 = simpleBeam.nodes.addNode(0,0,0,'N1')
N2 = simpleBeam.nodes.addNode(10,0,0,'N2')

N1.restraint = [1,1,1,0,0,0]
N2.restraint = [1,1,1,0,0,0]

M1 = simpleBeam.members.addMember(N1, N2)

model.loads.addPointLoad(M1, direction='Y', D=-10, location=50)

model.plot()
```
tactic 0.0.1
Occpupy this library name for future development of 3D simulator related to tactics2d.
Requires Python: >=3.7.0
Keywords: simulator,autonomous driving

# Tactics2D

[![Codacy](https://app.codacy.com/project/badge/Grade/2bb48186b56d4e3ab963121a5923d6b5)](https://app.codacy.com/gh/WoodOxen/tactics2d/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
[![Codecov](https://codecov.io/gh/WoodOxen/tactics2d/graph/badge.svg?token=X81Z6AOIMV)](https://codecov.io/gh/WoodOxen/tactics2d)
![Test Modules](https://github.com/WoodOxen/tactics2d/actions/workflows/test_modules.yml/badge.svg?)
[![Read the Docs](https://img.shields.io/readthedocs/tactics2d)](https://tactics2d.readthedocs.io/en/latest/)
[![Downloads](https://img.shields.io/pypi/dm/tactics2d)](https://pypi.org/project/tactics2d/)

[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![Github license](https://img.shields.io/github/license/WoodOxen/tactics2d)](https://github.com/WoodOxen/tactics2d/blob/dev/LICENSE)

## About

Tactics2D is a Python library that provides diverse traffic environments, facilitating the development of driving decision-making models.

## Quick Start

### Install from PyPI

You can simply install Tactics2D from PyPI with the following command

```shell
pip install tactics2d
```

### Install from Github

You can also install Tactics2D from from its source on GitHub.

[TODO]

If no errors occurs, you should have installed Tactics2D successfully.

### Samples

[TODO: The command lines to run sample codes.]

## Citation

If you find Tactics2D useful, please cite this in your publication.

```bibtex
@article{li2023tactics2d,
  title={Tactics2D: A Multi-agent Reinforcement Learning Environment for Driving Decision-making},
  author={Li, Yueyuan and Zhang, Songan and Jiang, Mingyang and Chen, Xingyuan and Yang, Ming},
  journal={arXiv preprint arXiv:2311.11058},
  year={2023}
}
```
lapa-authentication-helper 0.0.1
helper to access the authentication service.

# lapa_authentication_helper

## about

helper to access the authentication service.

## installation

> pip install lapa_authentication_helper

## usage

[reference python file](./example.py)

## configs

1. lapa_authentication_helper\data\config.ini

## env

- python>=3.12.0

## changelog

### v0.0.1

- initial implementation.

## Feedback is appreciated. Thank you!
hack4u-testing 0.1.2
Una biblioteca para consultar cursos de hack4u, realizada durante la visualización de uno de estos

pip3 install hack4u
```

## Uso básico

### Listar todos los cursos

```python
from hack4u import list_courses

for course in list_courses():
	print(course)
```

### Obtener un curso por nombre

```python
from hack4u import get_course_by_name

course = get_course_by_name("Introducción a Linux")
print(course)
```

### Calcular duración total de los cursos

```
from hack4u.utils import total_duration

print(f"Duración total: {total_duration()} horas")
py-steam-web-api 0.2
Python Client wrapper for Steam Web API
Requires Python: >=3.8
Keywords: steam,steam api,steam community,steam web api

## Description

---
This project is entirely based on the [Steam Web API](https://developer.valvesoftware.com/wiki/Steam_Web_API#JSON). You can find all the API information in the "all_api_info" folder, which includes both the APIs that require an API key and the ones that can be called without an API key. However, to ensure smooth usage, it is recommended that you [apply for an API key](https://steamcommunity.com/dev/apikey). Currently, the project has only implemented a portion of the API functionalities that I deemed useful.

## Get start
```shell
pip install py-steam-web-api
```
---
### basic
```python
from py_steam_web_api.api import SteamApi

s = SteamApi(key="xxxxxxxxxxxxxxxxxxxx")
```
### get user info 
```python
u = s.user.get_user_info(steamid=76561198155349454)
print(u.steamid, u.personaname)

# 76561198155349454 nike
```

### get friends
```python
# def get_friends(self, steamid: str) -> list[User]
u = s.user.get_friends(steamid=76561198155349454)
for i in u:
    print(i.steamid, i.personaname)

# 76561198098262862 nike
# 76561198400723672 aplay
# 76561198417914571 Π
```

### get level
```python

# def get_level(self, steamid: int) -> int:
a = s.user.get_level(steamid=76561198155349454)
print(a)

# 45
```

### get recent played games 
```python
#def get_recent_played_games(self, steamid: int) -> list[Game]:
a = s.game.get_recent_played_games(steamid=76561198155349454)
for i in a:
    print(i.appid)

# 271590
# 1260320
# 436150
# 322330
```

### all
```python
#user
def get_user_info(self, steamid: int) -> User:
def get_friends(self, steamid: int) -> list[User]:
def get_badges(self, steamid: int) -> list[Badge]:
def get_level(self, steamid: int) -> int:

#game
def get_recent_played_games(self, steamid: int) -> list[Game]:
def get_owned_games(self, steamid: int, include_appinfo=True) -> list[Game]:
def get_game_list(self, max_results=10000) -> list[Game]:

#stats
def get_number_of_current_players(self, appid: int) -> dict:
def get_player_achievements(self, appid: int, steamid: int) -> dict:
def get_schema_for_game(self, appid: int) -> dict:
def get_user_stats_for_game(self, appid: int, steamid: int) -> dict:


```