semvec/pypi-packages huggingface dataset:
engrproblems 2.1
ENGR 103 HW package, my first Programming package
Keywords: python,first package,Engr 103,OSU,ENGR 103 HW

# 10EngineeringProblems
Programs designed to Solve Engineering Problems
To run each program just import the module using
`import 10EngrProblems`
Then to run each block of code just call *HW* then the number of the problem you are working on. 
As seen below this is how you would run HW1()
`HW1()`
tubebank 1.0
Implementation of the Zukauskas correlations for crossflow over banks of tubes.
Requires Python: >=3.8, <3.11

# tubebank

tubebank is a Python library for dealing with tube banks in crossflow. You can learn more about tube banks at [Thermopedia](https://www.thermopedia.com/content/1211/).

tubebank is based on empirical data from A. Zukauskas. It is not highly accurate, especially in the low-intermediate Re range.

tubebank was developed by Ellie Litwack for Baltimore Aircoil Company.

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install tubebank.

```bash
pip install tubebank
```

## Usage

```python
import tubebank

#  If n <= 7, a correction factor for short tube banks is applied.
n = 6 #  The number of rows.
diameter = 0.02 #  tube diameters (length)
st = 0.03 #  transverse pitch (length)
sl = 0.03 #  longitudinal pitch (length)
mean_superficial_velocity = 2 #  (length/time)
density = 1.2 #  mass/(length*time)
viscosity = 1.8e-5 #  dynamic viscosity (mass/(length*time))
staggered = True #  False for inline banks, true for stagggered ones
#  alpha, beta, viscosity_ratio, and bounds_warnings are optional.
#  get the pressure drop across a tube bank
tubebank.get_pressure_drop(n, staggered, diameter, st, sl,
     mean_superficial_velocity, density, viscosity)

prandlt_number = 0.7
#  get the Nusselt number of a tube bank
#  valid for n >= 20, 0.7 ~<= Prandlt number ~<= 500,
#  1000 ~<= Re ~<= 2e6
tubebank.get_nusselt_number(staggered, diameter, mean_superficial_velocity, 
     density, viscosity, st, sl, prandlt_number, n)

```

## Contributing
Pull requests are welcome! I would be particularly interested in contributions that could incorporate more recent/accurate data. Find the project on [Github](https://github.com/ellieLitwack/tubebank).

## License
[MIT](https://choosealicense.com/licenses/mit/)
pystorms 1.0.0
Simulation sandbox for stormwater control algorithms

# pystorms: simulation sandbox for the evaluation and design of stormwater control algorithms
[![pystorms](https://github.com/kLabUM/pystorms/actions/workflows/python-package.yml/badge.svg?branch=master&event=push)](https://github.com/kLabUM/pystorms/actions/workflows/python-package.yml)
[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/python/black)

## Overview 

This library has been developed in an effort to systematize quantitative analysis of stormwater control algorithms.
It is a natural extension of the Open-Storm's mission to open up and ease access into the technical world of smart stormwater systems.
 Our initial efforts allowed us to develop open source and free tools for anyone to be able to deploy flood sensors, measure green infrastructure, or even control storm or sewer systems.
 Now we have developed a tool to be able to test the performance of algorithms used to coordinate these different sensing and control technologies that have been deployed throughout urban water systems.    

For the motivation behind this effort, we refer the reader to our manuscript [*pystorms*](https://dl.acm.org/citation.cfm?id=3313336). In general, this repo provides a library of `scenarios` that are built to allow for systematic quantitative evaluation of stormwater control algorithms.


## Getting Started 

### Installation 

**Requirements**

- PyYAML >= 5.3
- numpy >= 18.4
- pyswmm


```bash 
pip install pystorms
```

Please raise an issue on the repository or reach out if you run into any issues installing the package. 

### Example 

Here is an example implementation on how you would use this library for evaluating the ability of a rule based control in maintaining the flows in a network below a desired threshold. 

```python 
import pystorms 
import numpy as np

# Define your awesome controller 
def controller(state):
	actions = np.ones(len(state))
	for i in range(0, len(state)):
		if state[i] > 0.5:
			actions[i] = 1.0
	return actions 
	

env = pystorms.scenarios.theta() # Initialize scenario 

done = False
while not done:
	state = env.state()
	actions = controller(state)
	done = env.step(actions)

performance = env.performance()

```

Detailed documentation can be found on the [webpage](https://www.pystorms.org)
basictwitternlp 0.1.1
Scrape Twitter based off query and runs NLTK vader and cos similarity model
Requires Python: >=3.6, <4

Basic Twitter NLP
----
Description: Simple set of comands to work with twitter and text sediment analysis

NEEDED: Twitter Developer account for bearer token [Twitter Developer](https://developer.twitter.com/en/docs/platform-overview)

### Getting Started 
-----
Build Database to Store tweets and analysis. It will create the 5 tables needed for the process 
```python
db_init(con)
```
Add Querys. It takes any query that is allowed by your Twitter api acesses. [Twitter Query Help Guide](https://developer.twitter.com/en/docs/tutorials/building-high-quality-filters)
```python
add_query(twitter_query, con)
```
Run Process. This will run the scrape and NLP process and store them in the tables
```python
run_tw_nlp(con, client, query=None, inc_rt=False)
````
con : SQLite3 connection   ``` con = sqlite3.connection('DATABASE_NAME.db')```

client : twitter bearer token ``` client =  tweepy.Client(bearer_token='bearer') ```

query : query index number which can be found in the "query_idx" column in the queries table

inc_rt : to include retweets in text analysis
10EngrProblems 1.0
10 Engineering Problem Soultionns
Requires Python: >=3.6

# 10EngineeringProblems
Programs designed to Solve Engineering Problems
To run each program just import the module using
`import 10EngrProblems`
Then to run each block of code just call *HW* then the number of the problem you are working on. 
As seen below this is how you would run HW1()
`HW1()`
package-name-final 0.0.1
Criação de pacotes, desafio do bootcamp coagnizant.
Requires Python: >=3

# image-processing-final
Criação de pacotes, no bootcamp da DIO, realizando manutenção nos estudos, na terceira tentativa.

# Link
[Link do Desafio!!!! 'clique aqui'](https://web.dio.me/project/descomplicando-a-criacao-de-pacotes-de-processamento-de-imagens-em-python/learning/3d3925ad-7a05-4068-9cf9-7f3f7b18e99f?back=/track/cognizant-cloud-data-engineer-2&tab=undefined&moduleId=undefined)