Saravanan666/pypi-org huggingface dataset:
Package: ramagopr-myproject
Make sure you have upgraded version of pipWindowspy -m pip install --upgrade pipLinux/MAC OSpython3 -m pip install --upgrade pipCreate a project with the following structurepackaging_tutorial/
├── LICENSE
├── pyproject.toml
├── README.md
├── setup.cfg
├── src/
│   └── example_package/
│       ├── __init__.py
│       └── example.py
└── tests/
touch LICENSE
touch pyproject.toml
touch setup.cfg
mkdir src/mypackage
touch src/mypackage/__init__.py
touch src/mypackage/main.py
mkdir testspyproject.tomlThis file tells tools like pip and build how to create your project[build-system]
requires = [
    "setuptools>=42",
    "wheel"
]
build-backend = "setuptools.build_meta"build-system.requires gives a list of packages that are needed to build your package. Listing something here will only make it available during the build, not after it is installed.build-system.build-backend is the name of Python object that will be used to perform the build. If you were to use a different build system, such as flit or poetry, those would go here, and the configuration details would be completely different than the setuptools configuration described below.Setup.cfg setupUsing setup.cfg is a best practice, but you could have a dynamic setup file using setup.py[metadata]
name = example-pkg-YOUR-USERNAME-HERE
version = 0.0.1
author = Example Author
author_email = author@example.com
description = A small example package
long_description = file: README.md
long_description_content_type = text/markdown
url = https://github.com/pypa/sampleproject
project_urls =
    Bug Tracker = https://github.com/pypa/sampleproject/issues
classifiers =
    Programming Language :: Python :: 3
    License :: OSI Approved :: MIT License
    Operating System :: OS Independent

[options]
package_dir =
    = src
packages = find:
python_requires = >=3.6

[options.packages.find]
where = srcRunning the buildMake sure your build tool is up to dateWindowspy -m pip install --upgrade buildLinux/MAC OSpython3 -m pip install --upgrade buildCreate the buildpy -m buildReferenceshttps://packaging.python.org/tutorials/packaging-projects/
Package: ramanchada2
ramanchada2ramanchada2 is meant to fill the gap between the theoretical Raman analysis and the experimental Raman spectroscopy by providing means to compare data of different origin.For more information, see:https://github.com/h2020charisma/ramanchada2https://h2020charisma.github.io/ramanchada2/ramanchada2.htmlhttps://github.com/h2020charisma/ramanchada2/tree/main/examples🇪🇺 This project has received funding from the European Union’s Horizon 2020 research and innovation program undergrant agreement No. 952921.
Package: ramanfitter
ramanfitterThis package seeks to provide and easy and efficient matter for fitting Raman data with Lorentzian, Gaussian, or Voigt models.Developed by John Ferrier, NEU Physics (c) 2022Quickstart ExampleFor a simple run,importosimportnumpyasnpfromramanfitterimportRamanFitterfilename=os.path.join('path','to','data.csv')# Get Filedata=np.genfromtxt(filename,delimiter=',')# Open Filex=data[:,0]# Parse x-valuesy=data[:,1]# Parse y-valuesRF=RamanFitter(x=x,y=y,autorun=True)# Run Fitter automaticallycomponents=RF.comps# Returns a dictionary of each curve plotcurveParams=RF.params# Returns a dictionary of the parameters of each Lorentzian, Gaussian, or Voigt curvebestFitLine=RF.fit_line# Returns the plot data of the modelFor more control over parametersimportosimportnumpyasnpfromramanfitterimportRamanFitterfilename=os.path.join('path','to','data.csv')# Get Filedata=np.genfromtxt(filename,delimiter=',')# Open Filex=data[:,0]# Parse x-valuesy=data[:,1]# Parse y-valuesRF=RamanFitter(x=x,y=y,autorun=False)# Run Fitter automatically''' Each step ran when autorun = False '''RF.NormalizeData()RF.Denoise(ShowPlot=True)RF.FindPeaks(showPlot=True)RF.FitData(type='Voigt',showPlot=True)components=RF.comps# Returns a dictionary of each curve plotcurveParams=RF.params# Returns a dictionary of the parameters of each Lorentzian, Gaussian, or Voigt curvebestFitLine=RF.fit_line# Returns the plot data of the modelOn 0.0.3, a new Mapper feature is added for handling mapped data. This example below creates a 4K video across a sweep of frequencies.from ramanfitter.mapper import Mapper

here    = os.path.abspath( os.path.dirname( __file__ ) )
fname   = os.path.join( here, 'sample_map', 'sample.txt' )
MP      = Mapper( file = fname, display_name = "Sample 1", output_path = os.path.join( here, 'sample_map' ), delimiter = ',', provided_img=img, makePlot=False, makeVideo=True, plotType='imshow', resolution = '4k')
Package: ramanspy
RamanSPyRamanSPyis an open-source Python package for integrative
Raman spectroscopy data analysis.Key featuresCommon data formatData loadersPreprocessing methodsPreprocessing pipeliningPreprocessing protocolsAnalysis methodsVisualisation toolsAI integrationDatasetsMetricsSynthetic data generator (new in versions >= 0.2.0)InstallationRamanSPyhas been published on PyPI and can be installed
via pip:pip install ramanspyCode exampleBelow is a simple example of howRamanSPycan be used to
load, preprocess and analyse Raman spectroscopic data. Here, we load a
data file from a commercial Raman instrument; apply a preprocessing
pipeline consisting of spectral cropping, cosmic ray removal, denoising,
baseline correction and normalisation; perform spectral unmixing; and
visualise the results.import ramanspy as rp

# load data
image_data = rp.load.witec("<PATH>")

# apply a preprocessing pipeline
pipeline = rp.preprocessing.Pipeline([
    rp.preprocessing.misc.Cropper(region=(700, 1800)),
    rp.preprocessing.despike.WhitakerHayes(),
    rp.preprocessing.denoise.SavGol(window_length=9, polyorder=3),
    rp.preprocessing.baseline.ASPLS(),
    rp.preprocessing.normalise.MinMax()
])
data = pipeline.apply(image_data)

# perform spectral unmixing
nfindr = rp.analysis.unmix.NFINDR(n_endmembers=5)
amaps, endmembers = nfindr.apply(data)

# plot results
rp.plot.spectra(endmembers)
rp.plot.image(amaps)
rp.plot.show()DocumentationFor more information about the functionalities of the package, refer to
thedocumentation.CreditsIf you use this package for your research, please cite our paper:Georgiev, D., Pedersen, S., Xie, R., Fernández-Galiana, Á., Stevens, M., & Barahona, M. (2023). RamanSPy: An open-source Python package for integrative Raman spectroscopy data analysis. ChemRxiv. doi:10.26434/chemrxiv-2023-m3xlm@article{ramanspy_2023,title={RamanSPy: An open-source Python package for integrative Raman spectroscopy data analysis},author={Georgiev, Dimitar and Pedersen, Simon Vilms and Xie, Ruoxiao and Fernández-Galiana, Álvaro and Stevens, Molly M. and Barahona, Mauricio},journal={ChemRxiv},publisher={Cambridge Open Engage},year={2023},DOI={10.26434/chemrxiv-2023-m3xlm}}Also, if you findRamanSPyuseful, please consider leaving a star onGitHub.
Package: ramantools
ramantoolsTools for analyzing Raman spectroscopy data, measured by a Witec confocal Raman microscope.Documentation can be found here:zrbyte.github.io/ramantoolsInstallation:pip install ramantoolsIf you use this package in your publication, consider citing it:
Peter Nemes-I. (2023) “zrbyte/ramantools: v0.3.1”. Zenodo. doi: 10.5281/zenodo.10143138.
Package: ramapi
ramapiPython implementation for the Rick and Morty APIhttps://rickandmortyapi.com/Free software: MIT licenseDocumentation:https://ramapi.readthedocs.io.FeaturesAll methods returns jsonBase features:api_info() returns api informationschema() returns the json outlineCharacter,Location,Episode featutes:get_all() returns all valuesget() Takes a perimeter and returns a valuefilter() Returns filtered resultsschema() Returns json outlineFor detailed information and usage instrustions:Read Docs athttps://ramapi.readthedocs.ioVisit official API Docshttps://rickandmortyapi.com/documentationCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2018-08-08)First release on PyPI.
Package: ramba
Ramba is a Python project that provides a fast, distributed, NumPy-like array API using compiled Numba functions
and a Ray or MPI-based distributed backend.  It also provides a way to easily integrate Numba-compiled remote
functions and remote Actor methods in Ray.The main use case for Ramba is as a fast, drop-in replacement for NumPy.  Although NumPy typically uses C
libraries to implement array functions, it is still largely single threaded, and typically does not make
use of multiple cores for most functions, and definitely cannot make use of multiple nodes in a cluster.Ramba lets NumPy programs make use of multiple cores and multiple nodes with little to no code changes.ExampleConsider this simple example of a large computation in NumPy:# test-numpy.pyimportnumpyasnpimporttimet0=time.time()A=np.arange(1000*1000*1000)/1000.0B=np.sin(A)C=np.cos(A)D=B*B+C**2t1=time.time()print(t1-t0)Let us try running this code on a dual-socket server with 36 cores/72 threads and 128GB of DRAM:% python test-numpy.py
47.55583119392395This takes over 47 seconds, but if we monitor resource usage, we will see that only a single core is used.  All others remains idle.We can very easily modify the code to use Ramba instead of NumPy:# test-ramba.pyimportrambaasnp# Use ramba in place of numpyimporttimet0=time.time()A=np.arange(1000*1000*1000)/1000.0B=np.sin(A)C=np.cos(A)D=B*B+C**2np.sync()# Ensure any remote work is complete to get accurate timest1=time.time()print(t1-t0)Note that the only changes are the import line, and the addition of thenp.sync().  The latter is only needed to wait for
all remote work to complete, so we can get an accurate measure of execution time.Now let us try running the ramba version:% python test-ramba.py
3.860828161239624The Ramba version saturates all of the cores, and results in about 12x speedup over the original numpy version. (Why only 12x?  Three factors
contribute to this: 1) this total includes some of the initialization time; 2) Time for JIT compile (~1 second here); 3) This code is
memory-bandwidth bound, so after a point, additional cores will just end up waiting on memory).  Importantly, this performance gain
is achieved with no significant change to the code.
Package: rambenchmark
Simple RAM benchmark for Linux.Simple RAM BenchmarkThis is a simple RAM benchmark written in C++.
It allows checking approximate RAM speed. The code creates a 1 GiB (1024*1024*1024 bytes) buffer, fills it with zeroes,
scans the buffer, and measure the time.Note: This is only experimental code written to check the RAM speed on Linux. There are probably better tools for memory analysis available like memtest86.RequirementsUnix/Linux OS (can be easily ported to Windows)g++ compiler compatible with OpenMP (for multi-threaded variant)at least 1 GB free RAM (for buffer)Install and run using pipTo execute the benchmark, you only have to meet the requirements and run the below commands:pipinstallrambenchmark
rambenchmarkCompile and run manuallyIf you prefer to compile and execute the code manually, you can do that by running the following commands:gitclonegit@github.com:rsusik/rambenchmark.gitcdrambenchmark/rambenchmark
g++-O3-std=c++11-fopenmp-orambench./rambench.cpp
./rambenchTestsThe benchmark uses two functions for tests:memset()memchr()OutputThe benchmark produces below example output:======================================================================
BENCHMARKING RAM WITH MULTI THREADS
(...please wait...)

4 concurrent threads are supported.

----------------------------------------------------------------------
MEMSET TEST

RESULT of filling 1GiB buffer with zeros.
>>> 0.0654 (s) / 16415.2 (MB/s) <<<

                   Details
  #Threads        Time (s)      Speed (MB/s)
         1      0.0654 (s)    16415.2 (MB/s)
         2      0.0663 (s)    16189.3 (MB/s)
         3      0.0708 (s)    15161.6 (MB/s)
         4      0.0750 (s)    14299.5 (MB/s)

----------------------------------------------------------------------
MEMCHR TEST

RESULT of scanning 1GiB buffer.
>>> 0.0776 (s) / 13820.1 (MB/s) <<<

                   Details
  #Threads        Time (s)      Speed (MB/s)
         1      0.1686 (s)     6365.2 (MB/s)
         2      0.0985 (s)    10893.6 (MB/s)
         3      0.0874 (s)    12281.8 (MB/s)
         4      0.0776 (s)    13820.1 (MB/s)

======================================================================
Package: rambo
A command line sprite tool for smashing your images into sprites.Includespypacker, written by Joe Wezorek.FeaturesAutomatic support for multiple sprite resolutions (based on folder names)pngcrush for a low-fat dietProduces an HTML test page so can preview your spritesPython, so it’s blazing fastSet up your imagesYou’ll need to drop your sprite images in a sub-folder for each pixel aspect ratio.Eg, sprites/
      foo/           (the 1x has no prefix. Your sprite will be called this.)
      foo-0.75x/     (smaller than 1x for poxy androids. Use the same base-name `foo`)
      foo-1.5x/      (android pseudo-retina)
      foo-2x/        (true retina)
      bar/
      bar-2x/Usagepip install ramboThen run rambo from the command line:rambo --input "images/sprites" --output "images" --csspath "css" --cssfile "_sprites.scss" --sasspath "sass/sprites" --testpage_dir "site" --testpage_name "test_page.html"Arguments-h, --help                show this help message and exit
--input INPUT             Input directory, images/sprites
--output OUTPUT           Output directory, images/
--cssfile CSSFILE         CSS filename, _sprites.scss
--csspath CSSPATH         CSS output path, css
--sasspath SASSPATH       SaSS output path,  sass/sprites
--testpage_dir TEST_DIR   Cheat sheet dir, site/
--testpage_name TESTPAGE  Cheat sheet, cheat_sheet.html
Package: ramchet
# Ramchet module---This is a tool for upgrading the DataCanvas Platform.---## InstallationOur latest stable is always available on PyPi.```Shellpip install ramchet```---## DocumentationYou can set up few parameters for this tool```Shell$ ramchet --helpUsage: ramchet [OPTIONS] COMMAND [ARGS]...Options:-v, --version--help         Show this message and exit.Commands:command     Get startting docker container command of one...components  Get versions of all components for upgradingupdate      update one componentversion     Get version of one component```---## ContactIf you have any questions, welcome to send an email to <a class="email" href="mailto:xiaoh@about.me">xiaoh@about.me</a>---### END
Package: ramCOH
ramCOHLibrary for processing and peak fitting of Raman spectra, targeted at CO2fluids and (hydrous) silicate glassesDocumentationCode documentation is available atramcoh.readthedocs.ioInstallationramCOH can be installed with pip by runningpip install ramCOHin a terminal.If you would like to install from a specific git branch or release instead runpip install git+https://github.com/TDGerve/ramCOH.git@tagwheretagshould be repleaced by the release tag or branch name (e.g.v1.0ordevelopment)
Package: ramesh
They are funcion
1-diamond
/2-ramgenrator
/3-csvhelper.main()
/4-BBF
/5-ramgui
/6-i_sort
/7-b_sort
/8-s_sort
/9-b_search
/10-position
/11-mergesort
/12-lineasearch
/13-pattern 1-12
/14-notepad
/15-dice
/16-cube
/17-csvreaderop
/18-table
/19-ramhasher.main()
launch on 23/05/2022
Package: ramjet
Ramjet===[![versions](https://img.shields.io/badge/version-v1.8.1-blue.svg)]()[![PyPI version](https://badge.fury.io/py/ramjet.svg)](https://badge.fury.io/py/ramjet)[![versions](https://img.shields.io/badge/license-MIT/Apache-blue.svg)]()[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)> わが征くは星の大海 —— Yang Wen-li| ![](http://7xjvpy.dl1.z0.glb.clouddn.com/ramjet.jpg) ||:--:|| 后台脚本的引擎 |## Links- [Documents](http://laisky.github.io/ramjet/)- [Github](https://github.com/Laisky/ramjet)- [PyPI](https://pypi.python.org/pypi/ramjet)## Install & RunNeed Python3.5.x.```sh# Install from pypi$ pip install ramjet``````sh# Install from source$ python setup.py install$ python -m ramjet [--debug=true]```## Description基于 asyncio 和 consurrent.futures 运行脚本（`tasks`）。每一个 task 都需要实现接口 `bind_task()`。利用 `ioloop`、`thread_executor`、`process_executor` 自行实现运行逻辑。## Demo### 异步```pyimport randomimport asynciofrom ramjet.engines import process_executor, thread_executor, ioloopdef bind_task():# 将任务添加进事件循环中asyncio.ensure_future(async_task())async def async_task():await asyncio.sleep(3)for i in range(10):asyncio.ensure_future(async_child_task(i))async def async_child_task(n):await asyncio.sleep(random.random())print('child task {} ok!'.format(n))```### 多线程 & 多进程需要注意子进程没法回收，所以请确保 task 可以很好的结束。```pyfrom ramjet.engines import process_executor, thread_executor, ioloopdef bind_task():# 多线程thread_executor.submit(task, your_arguments)# 多进程process_executor.submit(task, your_arguments)def task(*args, **kw):pass```### 定时任务```pyfrom ramjet.engines import process_executor, thread_executor, ioloopdef bind_task():delay = 3600ioloop.call_later(delay, task, your_auguments)def task(*args, **kw):# 可以在 task 内设置下一次执行的时间# ioloop.call_later(delay, task, *args, **kw)```### HTTP```pyfrom aiohttp import webfrom ramjet.settings import loggerlogger = logger.getChild('tasks.web_demo')def bind_task():logger.info("run web_demo")def bind_handle(add_route):add_route('/', DemoHandle)class DemoHandle(web.View):async def get(self):return web.Response(text="New hope")```## Versions[更新日志](https://github.com/Laisky/ramjet/blob/master/CHANGELOG.md)
Package: ramka
ramkaramka(a Polish word for a small frame) is a very simple web framework written
in Python. It is based on a very good courseBuilding Your Own Python Web Frameworkbytestdriven.iowhich I highly recommend.Please bear in mind that at the moment only very basic functionality is
implemented and that this framework is far from being finished. Having said
that, I do have some ideas for the future.At the moment, you can define some routes and then serve the content (HTML,
text, JSON) to the client. You can use dynamic routes and serve templates and
static files (like stylesheets and images). And that's it. A framework is
probably a big word for it but there is some potential for it to grow.As I said it's still a work in progress. Some features I am planning to add:database support - there are no plans to implement custom ORM, but integrating
one of the existing ones (like SQLAlchemy) is probably a good start,authentication - it can use databases or some different method,plugins - the goal is to add a plugin mechanism and add more features as
installable plugins.There will be probably more but it's difficult for me to say at the moment.
Anyway, I would treat this as a learning project rather than a real framework.
Feel free to try it out and send me any feedback.DocumentationThe documentation is available athttps://ramka.readthedocs.io/.InstallationTo install the package usingpip, run the following command:pipinstallramkaTo add it as apoetrydependency, run:poetryaddramkaLicenseMIT
Package: ramlpy
RAML parsing library for pythonLibrary in very active development stage, is not recommended for use in production.Supports only RAML 1.0 and Python 3.The main goal of this library:Fast incoming HTTP requests validation (Resource URI, HTTP method, body)Outgoing HTTP responses validation (when running test with CI)Usable tool to use RAML Data types for validating any data structures (e.g. Rabbitmq queues, any other stuff your API is working with)I also working on aiohttp middleware for super-easy integration, i plan to share it a little bit later.VersioningThis software followsSemantic Versioning
Package: ramlwrap
Ramlwrap is a toolkit for Django which allows a combination of rapid server prototyping as well as enforcement of API definition from the RAML api.RAML (and swagger) allow for rapid specification of API’s, but it can be hard to know if your engineers have programmed exactly what the API is, and that your code is enforcing the same schema that you have defined. Ramlwrap bridges the gap between the specification and the code. A developer provides a mapping table of URL to function, and the raml wrap builds a wrapper around those functions where validation of data occurs.When coupled with auto documentation (raml2html) this allows a fully integrated specification and code deployment to occur.
Package: rammon
Rammon (RAM Monitor)Rammon is a tool to alert you when your machine is running low on memory with a desktop notification.Notifications are sent using dbus meaning it's supported by a wide range of Linux window managers
such as Gnome, KDE and many more.RequirementsLinuxPython3.6systemd (required for auto-start)PyGI (not packaged on pypi, python3-gi for Ubuntu, python-gobject for ArchLinux)GLib 2.46+ and girepository 1.46+Usagerammon [-h | --help] [-d | --no-daemon] [--set OPTION=value] [command]

    Commands are:
       start      Start the memory monitor
       stop       Stop the memory monitor
       status     Check the status of the memory monitor
       enable     Set rammon to run on login as a systemd user service
       disable    Disable rammon's auto-start
       config     Get and set configuration options

    Check command options with:
       rammon <command> -h
Package: ramo
RamoRamo is an algorithmic game theory framework offering a collection of algorithms and utilities for computing or learning (approximate) equilibria in multi-objective games.Please visitRamo's docsfor a complete overview of the framework and its capabilities.InstallationInstalling Ramo is as easy as typingpipinstallramoIf you would like to install from source, simply download this project as a zip file and place the folder at your desired location.ContributingWe are building a library containing cutting edge research in multi-objective game theory. If you are working in this area and want to get involved, contributions are very welcome! Our focus is specifically on multi-objective games, but single-objective contributions are also welcome. If you are considering contributing, please send me a message (willem.ropke@vub.be) so we can discuss how to move forward.CitationTo cite the usage of this repository please use the following:@misc{ropke2022ramo,
  author = {Willem Röpke},
  title = {Ramo: Rational Agents with Multiple Objectives},
  year = {2022},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {\url{https://github.com/wilrop/mo-game-theory}},
}This repository contains (derivatives of) original work that has been published elsewhere. We present a complete overview of which algorithms come from which work inreferences.md.LicenseThis project is licensed under the terms of the MIT license.
Package: ramodels
MoLoRa Data ModelsRAModels - MoLoRa data validation models powered bypydantic.VersioningThis project usesSemantic Versioningwith the following strategy:MAJOR: Incompatible changes to existing data modelsMINOR: Backwards compatible updates to existing data models OR new models addedPATCH: Backwards compatible bug fixesAuthorsMagenta ApShttps://magenta.dkLicenseThis project:MPL-2.0Dependencies:pydantic:MITThis project usesREUSEfor licensing. All licenses can be found in theLICENSES folderof the project.DevelopmentPrerequisitesPoetryPre-commitGetting StartedClone the repository:git clone git@git.magenta.dk:rammearkitektur/ra-data-models.gitInstall all dependencies:poetry installSet up pre-commit:pre-commit installRunning the testsYou usepoetryandpytestto run the tests:poetry run pytestYou can also run specific filespoetry run pytest tests/<test_folder>/<test_file.py>and even use filtering with-kpoetry run pytest -k "Manager"You can use the flags-vxwherevprints the test &xmakes the test stop if any tests fails (Verbose, X-fail)Pre-commit usagePre-commit must either be used via your virtual environment or globally.
If you want to pre-commit globally, the following extra dependencies are needed:pip install mypy pydanticModelsLoRaLoRaimplements the OIO standard version 1.1. Thestandardwithspecification