semvec/pypi-packages huggingface dataset:
uisdata 0.1
Consumes the UIS Bulk Data Download System (BDDS): get, select, subset, merge metadata/labels, search, other utilities
Requires Python: >=3.6

# ***uisdata*** library
*uisdata* is a library for easy data access and manipulation of the datasets offered by the [**UNESCO Institute for Statistics** (UIS)](http://uis.unesco.org/).

## Library modules
*uisdata.bdds* is the first module developed to consume the dataset archives of the [**Bulk Data Download System (BDDS)**](https://apiportal.uis.unesco.org/bdds) repository. 

- Access any BDDS zip archive; download the archive from the repo to memory or access the archive on your local drive 
- Subset the datasets based on lists of countries, years and indicators
- Merge a dataset with its metadata (as columns or as a dictionary)
- Merge a dataset with its country and indicator labels
- Wrapper to do all the above with a single method
- Reshape tables from long to wide format (multiple options)
- Search utility to create lists of indicators and regions
- ... more to come ... 

## Source code and installation
The test version of the source code is currently hosted on PyPi at:  
https://pypi.org/project/uisdata/

## Python requirement
*uisdata* requires a python 64-bit version. 
It has not been tested extensively to find the minimal viable version, but it will work on: 
**python** >=3.6  (64-bit)

## Installation 
    pip install -i https://pypi.org/simple/ uisdata

## Modules Dependencies
*uisdata.bdds* has not been tested extensively to find the minimal viable versions for its dependencies.  
It requires the following libraries:  
**requests** - a standard for making HTTP requests in Python. It abstracts the complexities of making requests behind a simple API.    
**pandas** - an open-source Python Library providing high-performance data manipulation and analysis tool using its powerful data structures.    
**numpy** - NumPy is a Python library used for working with arrays. It also has functions for working in domain of linear algebra, fourier transform, and matrices.

## License
MIT License

## Background
Work on *uisdata* started in 2021 for facilitating programmatic access to the UIS datasets. It is still under development, and I will be adding features in future iterations.

## Tutorials / use-case
[*.bdds* Use-case](https://datalore.jetbrains.com/notebook/FaD1hIZ0s0XKrlZcWTMYVW/UrrXOcYJWCstRNMNPvzzPF/) is provided through dataLore.  
Clone the notebook to your dataLore account (sign-up required). 
Note that the library will self-update to the latest version.
p65a 0.0.1
Pythonic 6502 Assembler: An experimental alternative to traditional assemblers.
Requires Python: >=3.10

# p65a
Pythonic 6502 Assembler: An experimental alternative to traditional assemblers.

At this point I'm unsure whether it's a useful concept or not, but I quite enjoy
writing code this way. Consider the API to be unstable.

See the `examples/` directory for examples of code written using this library.

Here's a snippet from `examples/bootloader.py`, which showcases a few nice features:

```python
[...,
	lbl.CRC_LUT_HI,
		Db([crc16(bytes([i])) >> 8 for i in range(0x100)]),
	lbl.CRC_LUT_LO,
		Db([crc16(bytes([i])) & 0xff for i in range(0x100)]),

	lbl.crc_update, # input: A, clobbers: A, Y
		A <= A ^ zp.crc_hi,
		Y <= A,
		A <= zp.crc_lo,
		A <= A  ^ lbl.CRC_LUT_HI[Y],
		zp.crc_hi <= A,
		A <= lbl.CRC_LUT_LO[Y],
		zp.crc_lo <= A,
		RTS(),
...]
```

This snippet implements a CRC16 checksum function. The lookup tables are generated
automagically by Python list comprehensions.
Each "line" of assembly is an expression contained within a Python list. The
`<=` operator is overloaded to express assignment.

It is possible to make forward-references to labels. They are treated as symbolic
expressions until the layout of code is known (and thus, their concrete value),
and then the machine code can finally be finally emitted.

## TODO

- Make an installable package
- Put it on pypi
- Refactor - there's a lot of code in places it shouldn't be
- Documentation
pysecstring 0.1.9
Python implementation of Window's Securestring forked from aznashwan/py-securestring
Requires Python: >=3.5,<4.0

This package serves as a mean to save passwords securely in Windows 10 machines.
It uses PowerShell's `SecureString` function and objects.

# Installation

You install this package simply from PyPI.org by:

```
pip install pysecstring
```

You could pip install directly from this github repository - which is the development repository.

Also, you could install it by git cloning this repository and `poetry install` it.

```
git clone https://github.com/gwangjinkim/pysecstring.git

cd pysecstring
poetry install
```

# Usage

The functions `encrypt()` and `decrypt()` serve as pure Python equivalents of the `ConvertTo-SecureString` (or `Read-Host -AsSecureString`) and the `ConvertFrom-SecureString` functions in PowerShell.

`set_credentials()` asks you for entering your username and password (starred input), which will store your credentials in two separate files in form of `SecureStrings`
(hexed binary - with a seed generated inside your computer).

`get_credentials()` reads these stored files and packs the credentials into a `CredentialObject` also known from PowerShell (but a Python equivalent version of it).
When probing for `.password` and `.username` properties from this credential, property-methods decrypt them immediately into plain text (but they are nowhere stored in plain text form - to enhance safety).

At any time point and place in your script, username and password are stored only in their encrypted form.

`set_credentials()` and `get_credentials()` work only when run on the same machine. Because different machines use different salts for encryption and decryption.

```
# save your credentials in the files `.\.user` and `.\.pass` in your machine:
username_file = '.\.user'
pass_file = '.\.pass'
set_credentials(username_file, pass_file)
# then PowerShell asks you for input of username and pass
# and these are stored in the username and pass files in an encrypted form - SecureString

# reads-in the SecureStrings and return them as one credential object
co = get_credentials(username_file, pass_file) 


# these credential object you can probe using property methods to get the decrypted plain text forms on the fly
co.username # returns decrypted username
co.password # returns decrypted password
# the decryption happens when the properties are called (property objects)
```

This repository started as a fork of `aznashwan/py-securestring`.
luckylog 2.0.3
自定义日志模式

# -*- coding: UTF-8 -*-
##Version: 0.0.1
日志模板
目前仅支持自定义消息处理
使用log请直接再文件中导入  from luckylog import Logger
如需要保存为文件，则需要导入整个文件获取全局变量  import logger
执行：Logger.sccess(xxx)
文件中有两个全局变量，当设置 path 为保存的文件位置和格式，module为选择保存的类型
module = 'success,error,warning,tip' 目前有四种类型的日志消息
目前展示类型：运行时间、函数名称、文件路径、状态、行数,格式固定,固定调用即显示
success：成功； error：错误； warning：警告； tip：提示；

添加装饰器功能：
装饰器使用： from luckylog import logger  （注意是小写的l）
装饰器自带两个参数，success和fail，代表自定义的成功和失败自定义消息
使用：在需要使用的def放上  @logger(success=xxx,fail=xxx)
如果不定义消息，则默认成功为--Success，失败为--Fail
使用装饰器后可不用带异常错误处理
装饰器不能用在类class上，可能出现报错而日志显示成功的情况

增设全局变量debug_file，当debug_file传入文件路径时(包含文件本身及格式)，系统将判断函数执行正确性，失败则将报错写入路径中的文件
函数运行成功将不会保存并写入文件
debug_file保存内容：运行事件，函数名称，文件路径，报错信息
！！！！！debug_file的保存文件方式，目前仅支持 @logger() 装饰器形式的启用！！！！！

## v1.0.0
Logger改为元组形式，可输入不限定参数
装饰器增加Debug模式，from luckylog import luckylog
luckylog.Debug = True   可开启debug模式，默认关闭状态
Debug模式开启，使用装饰器，成功增加返回输入参数，失败增加返回参数和异常报错信息   Arguments/Exception
错误日志增加输入参数

## v1.0.3
1、修改书写错误worning改成warning，以前写法仍旧可用
2、修改书写错误erro改成error，方法名替换

## v1.0.4
1、修复装饰器使用不能获取返回值的bug

## v 2.0.0版本：
改动：
1、部分文字错误进行了修改
2、增加了日志文件跳转，在pycharm等编辑器上可以直接点击跳转页面
3、使用log_conf代替原来分散的日志配置，使用log_conf来进行统一管理，日志类型以列表形式传入
4、logger装饰器修改形参名为passed、failed
5、logger开放参数deep，默认为1，为当前调用深度，本身为0，调用一次为1，可自行设置
6、日志书写模式不再支持键值对方式，即Logger(test='测试')的形式
7、更改debug_file配置名称为error_file更贴近文件意义
8、修改Debug变量名称为detail，区别于debugger，为显示错误日志详细信息
9、增加debug功能，对函数详细步骤进行解析
double-elimination 1.4.1
A double elimination tournament match handler.
Requires Python: >=3.6

# Double Elimination
This is a python package to manage the matches for a double elimination tournament.

It doesn't currently handle the grand finals match if the loser wins the first match.

For usage, see the test files.

Create an issue if you have any suggested features, changes, or documentation. Pull requests welcome.

Install with `pip install double_elimination`
windbase 1.0.3.65
windbase in python
Requires Python: >=3

 # windbase


``windbase`` is util write in python

# Installation and Dependencies


Install ``windbase`` with 

```
pip install windbase
```

# Documentation


provide basic package of wind's packages
include :
1. tools
2. commengine
3. adminlite


# Changelog
## 2022/05/18/  Ver 1.0.2.0
1. add Tools.input_password
link-prediction 1.0.8
Predict links between screens of smartphone applications

# Link Prediction

_Link Prediction_ is a Python module that provides baseline models to predict links between the screens of smartphone applications.

1. It provides a heuristically constructed set of link data based on the [RICO dataset](https://interactionmining.org/rico).
2. It provides several heuristic and learning-based link prediction models that can be used using with hierarchical screen data.

This package is part of a master thesis project titled "Predicting Links for Mobile GUI Prototyping" by [Christoph A. Johns](mailto:christophjohns@aalto.fi?subject=[GitHub]%20Suggested%20Links%Figma%Plugin) at German Research Center for Artificial Intelligence (DFKI) and Aalto University.
The project is supervised by Michael Barz and Prof. Antti Oulasvirta.

## Requirements

Link Prediction is known to work with Python 3.10.3 and above.

## Installing

You can install the package using pip with the following command:

```Shell

pip install link-prediction

```

You can them import the necessary packages from `link_prediction`.

## Quickstart

Typically, link prediction involves (1) loading some screen data, (2) loading a pre-trained link prediction model and (3) predicting a link (or score) for a potential link from that data.

```Python
# Imports
from link_prediction.datasets import load_rico_links
import joblib

# Load some data
X = load_rico_links(download_external_data=True)

# Load a (pre-trained) model
model = "PageContainsLabel"
clf = joblib.load(f"models/{model}Classifier.joblib")

# Predict labels and scores
y_pred = clf.predict(X)
y_score = clf.decision_function(X)
```

There is also a CLI for simplified use:

```Shell
$ python3 -m link-prediction --source-screen path/to/view_hierarchy/324.json --source-element 76d99c7 --target-screen path/to/view_hierarchy/339.json --model PageContainsLabel
```

Keep in mind, however, that using the `link-prediction` package as shown above requires the original RICO dataset, the RICO<sub>links</sub> dataset and the pre-trained models to be present in the project directory.

## Contributors

Christoph A. Johns