semvec/pypi-packages huggingface dataset:
simple-chatwoot 0.0.2
A super simple package to connect to Chatwoot
Requires Python: >=3.6

# Simple Chatwoot

Simple-Chatwoot is a Python library for connecting to Chatwoot REST API.

## Usage

```python
import os
from dotenv import load_dotenv

from simple_chatwoot import ChatWoot

load_dotenv()

DOMAIN = os.getenv("DOMAIN") #https://chatwoot.example.com
API_ACCESS_TOKEN = os.getenv("API_ACCESS_TOKEN") #rkoo0op2PPsihsv8JW3IjfiF
ACCOUNT_ID = os.getenv("ACCOUNT_ID") #1
INBOX_ID = os.getenv("INBOX_ID") #1

chatwoot_client = ChatWoot(DOMAIN, API_ACCESS_TOKEN, ACCOUNT_ID, INBOX_ID)

contacts = chatwoot_client.search_contacts("henrique")
print(contacts)
```

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License
[MIT](https://choosealicense.com/licenses/mit/)
kosu 0.1.6
Build and maintain courses using Jupyter Notebooks.
Requires Python: >=3.6

# kōsu / コース

[![Tests](https://github.com/agilescientific/kosu/actions/workflows/tests.yml/badge.svg)](https://github.com/agilescientific/kosu/actions/workflows/tests.yml)
[![Build docs](https://github.com/agilescientific/kosu/actions/workflows/build-docs.yml/badge.svg)](https://github.com/agilescientific/kosu/actions/workflows/build-docs.yml)
[![PyPI version](https://img.shields.io/pypi/v/kosu.svg)](https://pypi.org/project/kosu/)
[![PyPI versions](https://img.shields.io/pypi/pyversions/kosu.svg)](https://pypi.org/project/kosu/)
[![PyPI license](https://img.shields.io/pypi/l/kosu.svg)](https://pypi.org/project/kosu/)

`kosu` is a command-line utility to help you build and maintain courses using Jupyter Notebooks.


## Installation

To install kosu:

    pip install kosu

Or if you want to upload to S3 later, use the `aws` option like so:

    pip install kosu[aws]

See [the documentation](https://code.agilescientific.com/kosu) for more information.


## Getting started

To set up a new collection of courses:

    mkdir mycourses
    cd mycourses
    kosu init

This will create several directories and files in the directory `mycourses`. You can run some of the other commands in this guide to see how they work.

The content of the course is controlled by `example-course.yaml`. Note that only `title` and `curriculum` are required fields. There is also a global control file, `.kosu.yaml`, which contains some parameters you will want to set and maintain.

To build the example course:

    kosu build example-course

This will create a ZIP file of the course content.

To add more courses using the same pool of content, add another YAML control file.


## Documentation

[Read the documentation](https://code.agilescientific.com/kosu) for more on using the tool, as well as for information about contributing to `kosu`, the licence, etc.
versionmanagerpy 1.0.2
A GitHub Project Version Manager.
Requires Python: >=3.6
Keywords: python,github,version,manager,version manager

# versionmanager.py
A GitHub Project Version Manager that polls latest version data from GitHub repo release tag.

# Installation
### PIP
[PyPI](https://pypi.org/project/versionmanagerpy/)

`> pip install versionmanagerpy`

# Usage
versionmanager checks the version passed to its constructor against the tag attached to the latest release on a GitHub repo. Comparing the given version string against the `tag_name` value at [https://api.github.com/repos/{author}/{projectName}/releases/latest](). This means release tag names need to be formatted specifically for this. Versionmanager doesnt support letters in version categories* and assumes a separator of a period unless told otherwise.

*A version category is a set of numbers separated by a uniform character (e.g. 2.0.3 has categories 2, 0, and 3). Using Semantic Versioning there are usually 3 version categories (major, minor, and patch) but versionmanager supports more categories as well. 
```
import versionmanagerpy

def main():
	vm = VersionManager("Aquatic-Labs", "Umbra-Mod-Menu", "2.0.4")
	
	vm.on_outdated += lambda: print("Outdated.")
	vm.on_current += lambda: print("Current.")
	vm.on_dev += lambda: print("Dev.")
	
	vm.check_status()

if __name__ == "__main__":
	main()

```
sourcetypes 0.0.4
Python Source Code Types For Inline Syntax Highlighting
Requires Python: >=3.7

# Python Source Code Types For Inline Syntax Highlighting

Type annotations for various languages, when applied to multi line strings will syntax 
highlighting with the `python-inline-source` VS Code plugin.

Supports `html`, `css`, `javascript`, `typescript`, `sql`, `graphql`, 
multiple *css extension languages*, *template languages* and many more, 
[see below](#supported-languages) for a full list.

Uses [typing.Annotated](https://docs.python.org/3/library/typing.html#typing.Annotated)
to annotate the `str` type with the language used. You can use 
[typing.get_type_hints](https://docs.python.org/3/library/typing.html#typing.get_type_hints) 
at runtime to determine the language that a string has been annotated with.

On Python versions prior to 3.9 uses [typing_extensions](https://pypi.org/project/typing-extensions/) to support `Annotated` types.

## Installation

```
pip install sourcetypes
```

## Example

[![Example](https://raw.githubusercontent.com/samwillis/python-inline-source/main/sourcetypes/docs/examples.png)](docs/examples.py)

## Usage

Use a type decoration named for language that you are using:

```
import sourcetypes

my_html_string: sourcetypes.html = """
  <h1>Some HTML</h1>
"""
```

or:

```
from sourcetypes import html

my_html_string: html = """
  <h1>Some HTML</h1>
"""
```

## Supported Languages

- `markdown` (aliased as `md`)
- `html`
- `django_html` (aliased as `django`)
- `django_txt`
- `jinja`
- `jinja_html`
- `css` (aliased as `style`, and `styles`)
- `scss`
- `less`
- `sass`
- `stylus`
- `javascript` (aliased as `js`)
- `jsx` (aliased as `javascriptreact`, and `react`)
- `typescript` (aliased as `ts`)
- `tsx` (aliased as `typescriptreact`)
- `coffeescript` (aliased as `coffee`)
- `sql`
- `json`
- `yaml`
- `graphql`
- `xml`
- `python`

## Release Notes

### [0.0.2] - 2022-03-13
- Doc tweaks

### [0.0.1] - 2022-03-11
- Alpha release
colored-python 1.2.1
A lightweight python module to print colored text to the terminal easily
Requires Python: >=3.6

<h1 align="center">Colored Python</h1>
<p>
  <img alt="Version" src="https://img.shields.io/badge/version-Your version.-blue.svg?cacheSeconds=2592000" />
  <a href="https://github.com/just-a-mango/opensource-template/blob/main/LICENSE" target="_blank">
    <img alt="License: MIT" src="https://img.shields.io/badge/License-MIT-yellow.svg" />
  </a>
</p>

<p align="center"><b><i>A lightweight python module to print colored text to the terminal easily </b></i></p>

## Description
A more detailed description of your project.

## 📝 License

Copyright © 2022 [Just_a_mango](https://github.com/just-a-mango).<br />
This project is [MIT](https://github.com/just-a-mango/coloredpython/blob/main/LICENSE) licensed.
colored-python-JUST-A-MANGO 1.0
A lightweight python module to print colored text to the terminal easily
Requires Python: >=3.6

<h1 align="center">Colored Python</h1>
<p>
  <img alt="Version" src="https://img.shields.io/badge/version-Your version.-blue.svg?cacheSeconds=2592000" />
  <a href="https://github.com/just-a-mango/opensource-template/blob/main/LICENSE" target="_blank">
    <img alt="License: MIT" src="https://img.shields.io/badge/License-MIT-yellow.svg" />
  </a>
</p>

<p align="center"><b><i>A lightweight python module to print colored text to the terminal easily </b></i></p>

## Description
A more detailed description of your project.

## 📝 License

Copyright © 2022 [Just_a_mango](https://github.com/just-a-mango).<br />
This project is [MIT](https://github.com/just-a-mango/coloredpython/blob/main/LICENSE) licensed.
pnlogger 1.0.7
Databridges Python server Library

nanuaddnumb1
========

## License


DataBridges JavaScript client Library
https://www.databridges.io/



Copyright 2022 Optomate Technologies Private Limited.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.





Node.js module that generates a nanu-addnumb1.

Uses crypto.randomBytes when available, falls back to unsafe methods for node.js <= 0.4.

To increase performance, random bytes are buffered to minimize the number of synchronous calls to crypto.randomBytes.

## Installation

   $ npm install nanu-addnumb1

## Usage

   var add = require('nanu-addnumb1');

   console.log(add(1,3,343,4,34,345));
anthros-core 1.1
environment, interfaces, tools and environment for development, testing
Requires Python: >=3.6

[[RUS]](docs/RUS.md)

# Welcome to Anthros-core!

Environment, interfaces and tools for your projects, as well as an interactive console for development and testing

## How to start?

Install the latest version of this package </br>
Create a *.py file at the root of your project </br>
Import AC: from anthros import core as ac </br>
Run interactive mode: ac.interfaces.console.run()

## Additionally

> How can I find out more about the components?

Everything is in the help, enter: help </br>
*but for now, everything is in russian, you can help us with the translation

> How can I contact the creators?

Join our communities: [Discord](https://discord.gg/3zR4Ffa6mX), [Vk](https://vk.com/anthros) </br>
You can also write to [me](https://vk.com/thunder_light) or join discord (Tand#9533)
vpype-dxf 0.2.0
vpype dxf plugin

# vpype-dxf
 vpype dxf loading plugin

Adds command dread (dxf-read) that reads dxf files and into the vpype pipeline.

# ezdxf

Ezdxf is used as the backend of this project. The `-Q`/`--query` feed directly into the [query field](https://ezdxf.readthedocs.io/en/stable/usage_for_beginners.html#query-dxf-entities) of the ezdxf query(), and the `-g`/`--groupby` option is directly in the groupby value. This will allow you to use *any* valid ezdxf properties to [groupby](https://ezdxf.readthedocs.io/en/stable/layouts/layouts.html#ezdxf.layouts.BaseLayout.groupby). The defaults are `*` for query and `color` for groupby.

## Examples

* `vpype <file> dread --groupby lineweight write lines.svg` -- This would load the file and group the layers such that each lineweight in the dxf document is a different grouped according to their lineweight.

* `vpype dread -Q 'LINE CIRCLE[color==1]' 3colors.dxf write lines-circ.svg` -- This finds and processes only the `LINE` and `CIRCLE` objects where `color==1` and writes those to the given file.

* `vpype dread -g lineweight file.dxf show --colorful` -- Will group by the lineweight and show colorful layer groupings of those groups. This can work wonders for visualizing a messy file.

* `vpype dread --groupby center circles.dxf stat` -- Will group objects by the center of their circles.

See the ezdxf documentation on query for advanced help.

https://ezdxf.readthedocs.io/en/stable/query.html

# Acknowledgement
* ezdxf author mozman did all the heavy lifting of parsing the dxf files.
* abruto's research and suggestions in issue [#5](https://github.com/tatarize/vpype-dxf/issues/5) lead to rather large increase in functionality.
deiteo-kafka-client 0.0.2a0
Python Kafka Client Developed By Deiteo Organisation
Requires Python: >=3.8,<4.0

# Deiteo Kafka Client

![example workflow](https://github.com/deiteo/deiteo-kafka-client/actions/workflows/merge.yaml/badge.svg)
![example workflow](https://github.com/deiteo/deiteo-kafka-client/actions/workflows/pr.yaml/badge.svg)
![example workflow](https://github.com/deiteo/deiteo-kafka-client/actions/workflows/wily.yaml/badge.svg)

A library creating an interface on top of `AIOKafkaProducer`. To handle specific needs of
projects within open source Deiteo organisation.

## Library Usage


### DeiteoKafkaAioProducer
* The `produce` method will accept topic content of type `str` or `Dict[str, Any]`, and will
convert this into a `byte string` to produce to topic.
* The `DeiteoKafkaAioProducer` will create its own event `loop`, or you can inject one.


#### Without providing loop
```python
from deiteo_kafka.producer.deiteo_kafka_aio_producer import DeiteoKafkaAioProducer

bootstrap_servers = "localhost:1234"
topic = "deiteo-input-feed"

topic_content = {"A": 0, "B": "a-string", "C": 0.1}
deiteo_kafka_aio_producer = DeiteoKafkaAioProducer(
    bootstrap_servers=bootstrap_servers,
    topic=topic,
)
await deiteo_kafka_aio_producer.producer.start()
await deiteo_kafka_aio_producer.produce(topic_content=topic_content)
```

#### Providing loop
```python
import asyncio
from deiteo_kafka.producer.deiteo_kafka_aio_producer import DeiteoKafkaAioProducer

loop = asyncio.get_event_loop()
bootstrap_servers = "localhost:1234"
topic = "deiteo-input-feed"

topic_content = {"A": 0, "B": "a-string", "C": 0.1}
deiteo_kafka_aio_producer = DeiteoKafkaAioProducer(
    bootstrap_servers=bootstrap_servers,
    topic=topic,
    loop=loop,
)
await deiteo_kafka_aio_producer.producer.start()
await deiteo_kafka_aio_producer.produce(topic_content=topic_content)
```

You can then stop the producer if needed by:

```python
await deiteo_kafka_aio_producer.producer.stop()
```

## Setup From Scratch

### Requirement

* ^python3.8
* poetry 1.1.13
* make (GNU Make 3.81)

### Setup

```bash
make setup-environment
```

Update package
```bash
make update
```

### Test

```bash
make test type=unit/integration
```

### Docker

The reason `docker` is used in the source code here, is to be able to build up an encapsulated
environment of the codebase, and do `unit/integration and load tests`.

```bash
make build-container-image
```

```bash
make get-container-info-environment
make run-container-tests type=unit
```
bisection-buffer-optimization 0.0.1
Package for running bisection simulation methods to determine red zone solution values for parts
Requires Python: >=3.9

# Bisection-Search-Optimization
This repository contains project work related to the bisection search optimization method for finding ideal buffers

## Structure
`main` contains the base tkinter GUI that drives the functionality. 

`modules` contains modules from the `ddmrp-buffer-tool` repository related to simulation. Overall the simulation methods remained mainly the same and are simply resued here.

`test` contains some files that can be used to test the tool

`out` is a standardized folder for outputting results from a run. If you have some interesting ones, feel free to check them in, but one day we'll clear this out and results can just be stored on local machines and not as part of the repo.

## Future Goals:
- Parallelization of simulation process for multiple parts
- Build process that generates an executable file for people to use and test without any code - DONE
- Exportable methods that can be extended to the `ddmrp-simulation-api` project for use in cloud infrastructure
- Performance enhancements keeping the simulation process as well as the optimization function as fast as possible