semvec/pypi-packages huggingface dataset:
setupcode 1.1
setup configs settings snippets
Requires Python: >=3.7
Keywords: configs,settings,setup,snippets

# setupcode

python setup configs settings snippets

## install

`pip install -e setupcode`

## usage

```python
import setupcode

setupcode.notebook.autoreload()
setupcode.notebook.output_transparent()
setupcode.notebook.plotly_render.default()
setupcode.notebook.plotly_theme_vbt.github_dark()
```
shellmate 1.0.4
ShellMate: A GPT-Powered CLI Tool for Explaining and Finding Shell Commands
Requires Python: >=3.6

# ShellMate: The AI-Powered CLI Assistant
## Hey Devs, Here's Something You'll Love!

Let's be real - we've all been there. Staring at the terminal, trying to remember that one Linux command. It doesn't matter if you're just starting out or if you've been in the game for years; sometimes those commands just slip your mind. And sure, you could open a browser, search through stacks of docs, but isn't that just... tedious? That's where ShellMate jumps in!

## The Real Problem? Our Forgetful Brains!

We're software developers. We write elegant code, tackle complex algorithms, and create amazing apps. But remembering every single command and its syntax? That's asking a bit much. Who hasn't forgotten a command or two, right? So, instead of losing time Googling or scrolling through manuals, why not have a quick, in-terminal helper? Enter ShellMate - your CLI's new best friend!


## Key Features
- AI-Powered Explanations: Understand any command in plain English with a simple query.
- All Platforms Welcome: Whether you're on Linux, Windows, or MacOS, it's got your back.
- Find Commands Fast: Describe what you want to do, and ShellMate will find the command for you.
- Stay in the Zone: All of this happens within your beloved terminal. No more context switching!
## How to Install

```bash
pip install shellmate
```

That's it! No complex setups, just a simple pip command.

# How to Use ShellMate

## Setting your API key
```bash
shellmate set_openai_api_key <YOU_OPENAI_API_KEY_HERE>
```
And even if you forget to this and just start running commands, you will first be asked to enter your apikey. You can also change your api key with this command.

## Need a Command Reminder?
```bash
shellmate explain "ls -l" -os linux
```
## Looking for the Right Command?

```bash
shellmate find "how to see disk usage" -os windows
```
## Examples
```bash
# Forgot how to list files in detail on Linux?
shellmate explain "ls -l" -os linux

# Need to check disk usage on Windows but can't remember how?
shellmate find "how to see disk usage" -os windows
```

## Join the Forgetful Devs Club!
We're all in this together - a community of brilliant minds who sometimes forget the basics. ShellMate isn't just a tool; it's our little helper in those "Oops, I forgot again" moments. So, embrace it, use it, and keep coding without those pesky interruptions!
setupj 1.0
setup configs settings snippets
Requires Python: >=3.7
Keywords: configs,settings,snippets

# codeutils

python setup configs settings snippets

## install

`pip install -e codeutils`

## usage

```python
import codeutils

codeutils.notebook.autoreload()
codeutils.notebook.output_transparent()
codeutils.notebook.plotly_render.default()
codeutils.notebook.plotly_theme_vbt.github_dark()
```
akrocansim 0.6.1
akrocansim is a CAN bus J1939 controller simulator
Requires Python: >=3.11
Keywords: J1939,CAN bus

# akrocansim
A CAN bus J1939 controller simulator.

[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/akrocansim)](https://github.com/cfsok/akrocansim)
[![PyPI - Version](https://img.shields.io/pypi/v/akrocansim?color=blue)](https://pypi.org/project/akrocansim/)
![PyPI - License](https://img.shields.io/pypi/l/akrocansim)


## Built with
- [python-can](https://github.com/hardbyte/python-can)
- [DearPyGUI](https://github.com/hoffstadt/DearPyGui)
- [openpyxl](https://openpyxl.readthedocs.io/)

## Features
- Integrates with all hardware CAN interfaces supported by python-can.
- Transmits configured J1939 PGNs to the CAN bus with the following methods:
  - continuous tx of all PGNs
  - all PGNs transmitted once on button press
  - per PGN transmission, either continuous or on button press
- GUI for setting SPN values:
  - sliders for changing continuous values
  - label selection for discrete values
  - direct entry of raw decimal values
  - direct entry of decoded decimal values

![Akrocansim demo screenshot](https://raw.githubusercontent.com/cfsok/akrocansim/main/docs/images/demo_2_Akrocansim.png)

![PCAN-View demo screenshot](https://raw.githubusercontent.com/cfsok/akrocansim/main/docs/images/demo_1_PCAN-View.png)

## Installation
Python 3.11 (64-bit) or higher is required.

```
pip install akrocansim
```

## Prerequisites
- A hardware CAN interface supported by python-can,
see https://python-can.readthedocs.io/en/v4.3.1/interfaces.html.
- A version of J1939 Digital Annex (J1939DA) from SAE International, see https://www.sae.org/standards/?search=j1939DA.
- A way to convert `.xls` to `.xlsx` if your copy of the J1939DA is in `.xls` format.

## Usage
```
python -m akrocansim
```

Upon initial run, a folder named `akrocansim` is created in your home folder hosting a starting configuration file.

Follow the instructions on the application and in the configuration file for next steps.

Upon successful parsing of the J1939DA, a series of json files are created in the `J1939` sub-folder inside the main configuration folder.
These can be inspected to evaluate parsing correctness.

The J1939DA PGN and SPN definition format is very irregular and parsing errors still exist.
You can raise a GitHub issue or a pull request if you think that an SPN has not been parsed correctly.

## Issues
[GitHub issue tracker](https://github.com/cfsok/akrocansim/issues)

## Discussions
[GitHub discussions](https://github.com/cfsok/akrocansim/discussions)
nwisepy 1.0.1
A simple tool to generate pairwise testing set
Requires Python: >=3.8

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
</head>
<body>
  <h1>How To Use This Tool</h1>

  <p>This project has already been published on PYPI so just follow the tutorial below. <b>In terminal</b></p>

  <code>pip install nwisepy</code>

  <p>and then in your <b>python file</b></p>

  <code>from nwisepy import Pairwise</code>
</body>
</html>
hashtree 1.1.6
Top-level package for hashtree.
Keywords: hashtree

hashtree
========

Generate BSD-style hash digest checksums for a list of files


![Image](https://img.shields.io/github/license/rstms/hashtree)

![Image](https://img.shields.io/pypi/v/hashtree.svg)



![Image](https://readthedocs.org/projects/hashtree/badge/?version=latest)

![Image](https://pyup.io/repos/github/rstms/hashtree/shield.svg)


* Free software: MIT license
* Documentation: https://hashtree.readthedocs.io.
```
Usage: hashtree [OPTIONS] [INFILE] [OUTFILE]

  generate hash digest for list of files

Options:
  --version                       Show the version and exit.
  -d, --debug                     debug mode
  --shell-completion TEXT         configure shell completion
  -h, --hash [sha512|md5|sha256|blake2b|sha3_256|sha224|blake2s|sha1|sha384|sha3_224|sha3_512|sha3_384]
                                  select checksum hash
  -p, --progress / -P, --no-progress
                                  show/hide progress bar
  -a, --ascii                     ASCII progress bar
  -f, --find / -F, --no-find      generate file list with 'find'
  -s, --sort-files / -S, --no-sort-files
                                  sort input/generated file list
  -o, --sort-output / -O, --no-sort-output
                                  sort output with 'sort'
  -b, --base-dir DIRECTORY        base directory for file list
  --help                          Show this message and exit.
```
```
Usage: hashtree [OPTIONS] [INFILE] [OUTFILE]

  generate hash digest for list of files

Options:
  --version                       Show the version and exit.
  -d, --debug                     debug mode
  --shell-completion TEXT         configure shell completion
  -h, --hash [sha3_256|blake2b|blake2s|sha384|md5|sha3_512|sha224|sha256|sha3_384|sha1|sha3_224|sha512]
                                  select checksum hash  [default: sha256]
  -p, --progress / -P, --no-progress
                                  show/hide progress bar  [default: p]
  -a, --ascii                     ASCII progress bar
  -f, --find / -F, --no-find      generate file list with 'find'  [default: f]
  -s, --sort-files / -S, --no-sort-files
                                  sort input/generated file list  [default: s]
  -o, --sort-output / -O, --no-sort-output
                                  sort output with 'sort'  [default: O]
  -k, --sort-key TEXT             sort key (sort -k KEY)  [default: 1.1]
  -b, --base-dir DIRECTORY        base directory for file list  [default: .]
  --help                          Show this message and exit.
```
bip39-mnemonic-decrypt 1.0.1
Decrypts jsBIP39 data.
Requires Python: >=3.6

# BIP39 Mnemonic Decrypt
Reference implementation of BIP-39: Mnemonic code for generating deterministic keys

# Abstract

This BIP describes the implementation of a mnemonic code or mnemonic sentence – a group of easy to remember words – for the generation of deterministic wallets.

It consists of two parts: generating the mnenomic, and converting it into a binary seed. This seed can be later used to generate deterministic wallets using BIP-39 or similar methods.

# Installation

To install this library and its dependencies use:

```
pip install bip39_mnemonic_decrypt
```
kage-cucounter 1.0.1
A hashtable based counter implemented in CUDA for high throughput.

## CuCounter: A Python *k*mer frequency counter object based on a massively parallel CUDA hash table

## Installation
CuCounter requires NumPy and CuPy. It also currently only supports Nvidia GPUs with CUDA.

Cucounter can be installed using pip:
```Bash
pip install kage-cucounter
````

.. or via manual installation:

* clone the CuCounter repository
* use pip to install all necessary dependencies as well as CuCounter from inside the cloned repository
```Bash
git clone https://github.com/jorgenwh/cucounter.git
cd cucounter
pip install -r requirements.txt
pip install .
```

## Usage
All of CuCounter's methods (including its constructor) will accept either NumPy or CuPy arrays.
CuPy arrays are preferred as it circumvents having to copy memory back and fourth between the host and device.
NumPy is used in the example below, but the same code would work if NumPy had been replaced with CuPy.
```Python
from cucounter import Counter
import numpy as np

# Create a static set of 100 million unique 64-bit encoded kmers as keys for the counter
unique_kmers = np.arange(100000000, dtype=np.uint64)

# Create counter object
counter = Counter(keys=unique_kmers)

# Create a chunk of 200 million kmers to count
kmers = np.random.randint(low=0, high=0xFFFFFFFFFFFFFFFF, size=(200000000,), dtype=np.uint64)

# Count the observed kmer frequencies. Kmers not present in the original key set are ignored
counter.count(kmers)

# Fetch the observed frequencies for the original key set
counts = counter[unique_kmers] 

counts.dtype # np.uint32
counts.shape # (100000000,)
```

CuCounter also supports counting the reverse complements of *k*mers aswell as the original *k*mer.
```Python
counter.count(kmers, count_revcomps=True)
```
TkClassWiz 1.4.10
Library for graphically defining objects based on class annotations. Works with Tkinter / TTKBootstrap
Requires Python: >=3.9
Keywords: Tkinter,TTKBootstrap,Python3,ObjectDef,ClassWiz,ClassWiz,GUI

=========================================================
TkClassWizard
=========================================================
TkClassWizard - define objects graphically based on class annotations.
The library allows users to create abstract "ObjectInfo" objects based on the class's parameters, which
can later be converted to real Python objects and vice versa.

---------------------
Links
---------------------
- `Releases <https://github.com/davidhozic/TkClassWizard/releases>`_
- Need help? Contact me in my `Discord server <https://discord.gg/DEnvahb2Sw>`_.
- **DOCUMENTATION**: https://tkclasswizard.readthedocs.io/

---------------------
Main features
---------------------
- Interactive definition of Python objects based on annotations.
- Tkinter based
- JSON templates
- Polymorphism
- Generic classes
- Type aliases
- Data validation
- Conversion of defined data to Python objects and vice-versa.

----------------------
Installation
----------------------
TkClassWizard can be installed though command prompt/terminal using the bottom commands.
        
Pre-requirement: `Python (minimum v3.9) <https://www.python.org/downloads/>`_


.. code-block:: bash

    pip install tkclasswiz

----------------------
Example
----------------------

.. image:: docs/source/guide/images/new_define_frame_struct_new_str.png
    :width: 15cm

.. code-block:: python

    import tkinter as tk
    import tkinter.ttk as ttk
    import tkclasswiz as wiz


    # Normal Python classes with annotations (type hints)
    class Wheel:
        def __init__(self, diameter: float):
            self.diameter = diameter

    class Car:
        def __init__(self, name: str, speed: float, wheels: list[Wheel]):
            self.name = name
            self.speed = speed
            self.wheels = wheels

    # Tkinter main window
    root = tk.Tk("Test")

    # Modified tkinter Combobox that will store actual objects instead of strings
    combo = wiz.ComboBoxObjects(root)
    combo.pack(fill=tk.X, padx=5)

    def make_car(old = None):
        """
        Function for opening a window either in new definition mode (old = None) or
        edit mode (old != None)
        """
        assert old is None or isinstance(old, wiz.ObjectInfo)

        window = wiz.ObjectEditWindow()  # The object definition window / wizard
        window.open_object_edit_frame(Car, combo, old_data=old)  # Open the actual frame

    def print_defined():
        data = combo.get()
        data = wiz.convert_to_objects(data)  # Convert any abstract ObjectInfo objects into actual Python objects
        print(f"Object: {data}; Type: {type(data)}",)  # Print the object and it's datatype


    # Main GUI structure
    ttk.Button(text="Define Car", command=make_car).pack()
    ttk.Button(text="Edit Car", command=lambda: make_car(combo.get())).pack()
    ttk.Button(text="Print defined", command=print_defined).pack()
    root.mainloop()
streamlit-stacker 0.0.6
Tool allowing to stack streamlit commands and resolve them in a controlable manner.


# streamlit_stacker

streamlit_stacker is a python package implementing a main st_stacker class.
This class can be used with similar syntax as the streamlit module but the attribute calls will be stacked in a list (the stack) instead of being resolved. A simple call to the refresh() method will deal with rendering (=actually execute the corresponding streamlit commands of) the whole stack on demand.

Populating a stack with attribute calls, context mangers and callbacks thus becomes similar to setting up a gui layout in an object oriented manner.

On top of being added to the stack, all st_stacker attribute calls will return one or several st_output objects. These are meant to be placeholder objects anticipating the reception of actual outputs returned by streamlit attribute calls when they will get executed. 

The .value property will get actualized in real time as soon as the corresponding streamlit widgets have a non-empty state.

This module is very useful to implement stateful and/or dynamic execution of streamlit commands in an interactive web interface.

It is meant to support all streamlit commands and syntaxes allowed by the streamlit module. If not, feel free to report an issue, we'll work on it :).

## Installation

```bash
$ pip install streamlit-stacker
```

## Usage

```python
import streamlit as st
from streamlit_stacker import st_stacker

#shortcut
state=st.session_state

#define the stacker in state
if not 'stacker' in state:
    state.stacker=st_stacker()
stk=state.stacker

#resets all commands in the stacker to a non-rendered state, so that the next call to refresh will render them again
stk.reset()

if not 'test' in state:
    #stack a chat message and a button in a container, won't be rendered immediately
    state.c=stk.container()
    with state.c:
        with stk.chat_message(name='user'):
            stk.write("Hello!")
            
    #callback to add a new message when the button is clicked
    def on_click():
        with state.c:
            with stk.chat_message(name='user'):
                stk.write("Hello again!")

    stk.button("click me!",on_click=on_click)
    state.test=True

#render the stack: the chat message and the button will appear on screen on every rerun, even though the corresponding commands have been called only once at first run
#every click on the button will add another chat message to the container
stk.refresh()
```

## License

This project is licensed. Please see the LICENSE file for more details.

## Contributions

Contributions are welcome. Please open an issue or a pull request to suggest changes or additions.

## Contact

For any questions or support requests, please contact Baptiste Ferrand at the following address: bferrand.maths@gmail.com.
idstool 0.1.3
Python Tool to create IDS (Information delivery specification) files
Requires Python: >=3.10
Keywords: IDS,Information Delivery Specification,openBIM

# idstool
 Python Tool to create IDS (Information delivery specification) files for openBIM workflows.

 Currently built on IDS version 0.9.6


# Example

An example on how to use this library to create an IDS:

```python
import idstool as ids

spec1 = ids.Specification(name='Wall Specifications', ifc_version='IFC4',
                          applicability=ids.Applicability(facets=[ids.EntityFacet(ifc_class='IfcWall')]),
                          requirement=ids.Requirement(facets=[ids.AttributeFacet(name='Name')]))

spec2 = ids.Specification(name='Hackathon Pset', ifc_version='IFC4',
                          applicability=ids.Applicability(facets=[ids.EntityFacet(ifc_class='IfcWall')]),
                          requirement=ids.Requirement(facets=[ids.PropertyFacet(property_set='Hackathon2024', property_name='AEC_Hack', datatype='IFCTEXT')]))

ids_data = ids.InformationDeliverySpecification(
    title="AEC Hackathon Test IDS",
    version="0.1",
    purpose="Testing",
    specifications=[spec1, spec3]
)

ids.IDSSerializer.save_ids(filepath='example_ids', ids=ids_data)
```


# Limitations

- This README is still under construction =)
- Currently not all metadata for IDS files are actually written to file. author and date are skipped

# Next Steps

The following features will be added next:

- Utility functions to easily create simple Applicabilities and Requirements
df-csv-excel 0.1.43
Commonly used functions for Data Scientists
Requires Python: >=3.9

# read_csv_excel

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

## Overview

`read_csv_excel` is a Python library that provides a collection of common and customized functions for handling data, particularly CSV and Excel data. It simplifies the process of converting data into Pandas DataFrames, performing statistical analysis, and creating visualizations.


## Document
[Document](https://read-doc-1.readthedocs.io/en/main/index.html)


## Features

- CSV and Excel data conversion to Pandas DataFrames.
- Statistical analysis of DataFrames.
- Customized functions for common data handling tasks.
- Plotting functions for data visualization.

## Installation

You can install `read_csv_excel` using pip:

```
pip install df-csv-excel
```

pypi page link is here:(https://pypi.org/project/df-csv-excel/)

## Usage read and process data

Here is some examples for the functions, for more details, please refer to (https://pypi.org/project/df-csv-excel/)   
```
from df_csv_excel import read_data 

df = read_data.read_data_by_path('a.xlsx')
df['name'] = read_data.get_feature_from_json(df, 'json_column', ['key_name1', 'key_name2', 'key_name3])
df['time_column'] = read_data.foramt_date_column(df, 'date')
```

## Usage plot data

```
from df_csv_excel import read_data, plot_data 

df = read_data.read_data_by_path('a.xlsx')
plot_data.plot_histgram(df, 'column_name')
```

## Contributing
If you have suggestions, enhancements, or find issues, please feel free to contribute! Follow the Contribution Guidelines for more details.
pyZlBusSdk 0.1.0
ZeroLab wireless attitude chip, ZLBUS communication protocol API
Requires Python: >=3.10

# 使用如下

```python

import pyZlBusSdk.pyZlBus as zlb
import pyZlBusSdk.test as ts
import pyZlBusSdk.bleTest as bts

# 实例
ts.demo()
# bts.bleDemo('ZL24-00000001-0000')





```