semvec/pypi-packages huggingface dataset:
petro-python 1.0.2
A python package for pteroleum computation
Requires Python: >=3.6

# petro_py

## v1.0.2

### A python package  created by Ahmed alkhatim for petroleum computations with two sub modules for 
- Reservoir
- Production
### Beside :
- Oilfied Module: for gitting general and quick information about oilfield data



<!-- ![image](https://cloud.githubusercontent.com/assets/1942359/5570181/f656a484-8f7d-11e4-8ec2-558d022b13d3.png) -->

## Installation


<!--     To install the latest release version: -->

    pip install petro-python


## How it works


```python
import petro_py as ptr

```

<!-- * Now you can convert contents: `ipymd.convert(contents, from_='notebook', to='my_format')` or any other combination. -->

### Initializing an Oil Field module

```python
  field = ptr.OilField("path_to_file")
```

  > The `OilField` module instantiate an OilField class and then `an_oil_field` variable can access all the API of of `OilField` such as:
  
  * field.wells
  * field.number_of_wells
  * field.n_production_wells
  * field.injection_wells
  * field.n_injection_wells
  * field.converted_wells
  * as well as quick_view() method that give a quick view about your field
  


### Exapmle
for Volve dataset the output will be 

```python
  volve = ptr.OilField(file)
  
  volve.number_of_wells  # 7

  volve.production_wells
  # array(['15/9-F-1 C', '15/9-F-11', '15/9-F-12', '15/9-F-14', '15/9-F-15 D', '15/9-F-5'], dtype=object)
  
  volve.n_production_wells # 6

  volve.injection_wells
  # array(['15/9-F-4', '15/9-F-5'], dtype=object)

  volve.n_injection_wells # 2

  volve.converted_wells 
  # ['15/9-F-5']

  volve.quick_view()
  # number_of_wells : 7 number_of_columns : 18 number_of_records: 15634
  
```
cnblogs 1.0
测试包
Requires Python: >=3

123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123123
sa-decor 1.0.1
SQLAlchemy decorators for an optional connection/session dependency injection.
Requires Python: >=3.7

# sa_decor

SQLAlchemy decorators for an optional connection/session dependency injection.

[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

## usage with SQLAlchemy Core
You can set a global **engine** if you're using only one in your application.
```python
import sa_decor

sa_decor.set_global_engine(my_engine)
```

Annotate a function and add a named parameter **connection**.
```python
from sa_decor import with_connection

@with_connection()
def foo(a, b, *, connection):
    ...
    connection.execute(stmt)
    ...
```

If you're using multiple engines, you can provide them to each function separately.
```python
@with_connection(engine=my_other_engine)
def bar(a, b, *, connection):
    ...
    connection.execute(stmt)
    ...
```

Then either call the function without the parameter to let the decorator connect for you, or supply an existing connection.
```python
foo(1, 2)
foo(1, 2, connection=my_connection)
``` 

## usage with SQLAlchemy ORM sessions
There is a similar functionality available for ORM sessions, but you need to provide a **sessionmaker** object instead of an **engine** and add a **session** parameter. You also need to choose whether the session should be committed when the function finishes or even when the function raises an exception.
```python
sa_decor.set_global_sessionmaker(my_sessionmaker)


@with_session(commit=False)
def function_that_only_queries_data(*, session):
    ...
    session.execute(select_stmt)
    ...

@with_session(commit=True)
def function_that_updates_the_db(*, session):
    ...
    session.execute(insert_stmt)
    ...
    raise Exception  # the insert WILL NOT be commited

@with_session(force_commit=True)
def function_that_commits_no_matter_what(*, session):
    ...
    session.execute(insert_stmt)
    ...
    raise Exception  # the insert WILL be commited
```

The commit behaviour is ignored when the function is called with an existing session.
```python
function_that_commits_no_matter_what(session=my_session)
# not commited automatically!
my_session.commit()
```

## notes
This is the most useful when you have a bunch of functions that all rely on a connection/session but are sometimes called independently and sometimes from within a different function that also needs a connection.
```python
@with_connection()
def get_stuff(*, connection):
    ...

@with_connection()
def do_stuff(*, connection):
    ...
    get_stuff(connection=connection)  # nested calls can use the same connection
    ...


# somewhere else in the code, e.g. an API controller
def get():
    ...
    stuff = get_stuff()
    ...

def post():
    ...
    result = do_stuff()
    ...
```
freefft 0.0.8
Fast Fourier Transform (FFT) analyzer and condition monitoring software.
Requires Python: >=3.6
Keywords: free fft freefft vibration condition monitoring fast fourier transform signal analysis

# FreeFFT
FreeFFT is a [free](https://www.gnu.org/philosophy/free-sw.html) and open source vibration analsys software package.

<img src="https://github.com/fjpereny/freeFFT/blob/main/img/FreeFFT%20GUI%201.png?raw=true" alt="FreeFFT GUI">

## Features
- Simple & Intuitive Interface
- Two Column CSV Data Import Compatibility
- Time Slicing of Imported Data
- Autodetected Sampling Frequency & Nyquist Frequency
- RMS, Peak, and Peak-Peak Calculation
- Fast Fourier Transform (FFT)
- Data Zero Padding
- Multitude of Windowing Functions
- Export of Resulting Plots and Calculated Data

## System Requirements
FreeFFT is compatible with Linux, FreeBSD, MacOS, and Windows systems that have Python 3 installed.  

### Python Requirements
FreeFFT requires Python 3 and the following packages:
 - PyQt5
 - pyqtgraph
 - numpy
 - scipy
 - pandas

### Installing
Free FFT can be installed via PIP with the following terminal command:
```
pip install freefft
```

## Installing & Running
Simply pull the repository or download and extract all files into the directory of your preference.  The application is started by running main.py.  Optionally, main.py takes an argument to directly open a data file.

Opening the application:
```
python -m freefft
````
Opening the application directly with data file:
```
python -m freefft data.csv
```

## License
This software is released uner [GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007](https://www.gnu.org/licenses/gpl-3.0.en.html).

Copyright © 2022 [Frank Pereny](https://github.com/fjpereny/)

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.