Saravanan666/pypi-org huggingface dataset:
Package: dallinger
DallingerLaboratory automation for the behavioral and social sciences.FeaturesPerforms laboratory automation for the behavioral and social sciencesCoordinates participant recruitment using Mechanical TurkInstallTo install Dallinger, seethe instructions.DocumentationDocumentation is available on thedocumentation website.DemosDemonstration experiments are distributed separately in thedlgr.demospackage.ContributeIssue Tracker:http://github.com/Dallinger/Dallinger/issuesSource Code:http://github.com/Dallinger/DallingerSupportIf you are having issues, pleaselet us know.Subscribe to our Slack channelDallinger isopen-source, and iscompletely freeto use in
your experiments. However, to help users with technical issues and
experiment creation, the Dallinger team maintains aDallinger
support Slack channel. Access to the Dallinger support Slack
requires a$10 per month per user subscription,
with proceeds supporting the future development of Dallinger. Users are
free to subscribe for as many or as few months as they wish.To subscribe and gain access to the Slack support channel,
pleasedownloadand complete this invoice. Completed invoices, along with a check for
the appropriate amount, should be sent to the address on the invoice.
Upon the invoice being processed, the listed users will be added to the
Slack channel. If you are from a developing nation and are unable to
afford a subscription, please contact us directly.LicenseThe project is licensed under the MIT license.
Package: dallinger.bartlett1932
Frederic Bartlett’s 1932 bookRememberingdocuments early experiments
that explore how using and transmitting a memory can affect the memory’s
contents. Bartlett wanted to understand how culture shapes memory.
Inspired by Philippe (1897), he performed a series of experiments that
asked participants to repeatedly recall a memory or to pass it down a
chain of people, from one to the next. Bartlett showed that the process
of reproduction alters memories over time, causing them to take on
features from an individual’s culture. More generally, the methods he
developed expose cumulative effects of the forces that reshape and
degrade memories and how they impact the structure and veracity of what
we remember.Bartlett, F. C. (1932). Remembering. Cambridge: Cambridge University
Press.In this demo, a story is passed down a chain.
Package: dallm
Arcee:tulip:	The open source alignment toolkit for finetuning and deploying LLMs :tulip:Finetuning DatasetsThe Arcee toolkit contains routines for you to manage and generate finetuning datasets. The arcee toolkit supports supervised finetuning (SFT) aka intruction tuning.✍️ Instruction Set ✍️Instruction tuning datasets contain a series of prompt and completion examples.Instruction sets can be loaded from a csv.from arcee.data import InstructionSet
instruction_set = InstructionSet("./datasets/strip_api.csv")Or downloaded from the Arcee platformfrom arcee.data import InstructionSet
instruction_set = InstructionSet("https://app.arcee.ai/arcee/alpaca")Self-Instruct GenerationEvolv-Instruct GenertationExplain-Instruct GenerationFinetuning ModelsHuggingFacefrom arcee.models import LM
from arcee.data import Instuctions

lm = LM("falcon30b")
instructions = Instructions("./datasets/stripe-api.json")
lm.train(instructions)

lm.predict("Place an order for the LLM-9000 product for 100 USD to the card 3007200039992000")OpenAICohereTogetherMosaic MLLangChain Integrationfrom langchain import Arcee
#goes in llms/arcee.py

prompt_template = "Write a stripe API request for the following: {order}."

llm = Arcee(temperature=0)
llm_chain = LLMChain(
    llm=llm,
    prompt=PromptTemplate.from_template(prompt_template)
)
llm_chain("Place an order for the LLM-9000 product for 100 USD to the card 3007200039992000")Domain PretrainingComing soon!🗻 Arcee Platform 🗻Arcee offers a platform for managing your proprietary language models in production. We offer a version of our platform hosted in our cloud as well as a deployable version that you can take on prem.AuthenticaitonTo use the arcee platform, visithttps://app.arcee.com/api-settingsandexport ARCEE_API_KEY=*******in your environment.Dataset ManagemntView, search, and edit datasets.instruction_set.upload("project-name")Hosted TrainingHosted InferenceLifecycle Management
Package: dalpha
internal-sdkHow to installpip 으로 설치하는 경우install.sh 를 프로젝트에 복재해 사용합니다.poetry 로 설치하는 경우install_poetry.sh 를 프로젝트에 복재해 사용합니다.CI 에 설정하는 법CI 에 다음 step 을 추가합니다.How to useimportdalphaSDK 개발자가 교체하는 법make buildversion 맞춰서 S3 업로드 (dalpha-internal-sdk)배포 방법pip install build twinegit pull origin mainpython3 -m buildpython3 -m twine upload dist/*
Package: daltonapi
DaltonNote that this is an alpha release of the project, and large changes may occur, however it is intended to keep the access paths to functions and classes the same.This Python package provides a wrapper providing read-only access to the Atomic Assets API on the WAX blockchain. Full docs being assembled atRead the Docs.DaltonFeaturesIn developmentInstallationExamplesCreating an Atom objectRetrieving an assetRetrieving assets based on criteriaDocumentationContributingAttributionContact meFeaturesAtomclass for accessing Atomic Asset DataPythonic classes for Atomic Assets, Templates, Schemas, Collections, Transfer events, withA growing collection of class methods for working with API data.In developmentHave a look at our roadmaphere.InstallationThe recommended method of installation is through PyPI and pippython -m pip install daltonapiFun fact: This package is named after John Dalton, a pioneer of Atomic Theory.ExamplesCreating an Atom objectThe main class of the Dalton package is the Atom class, which is used as an interface to the API>>> from daltonapi.api import Atom

>>> atom = Atom()Retrieving an assetOnce you have created an Atom, it's simple to get information about an asset.>>> my_asset = atom.get_asset("1099519242825")
>>> print(my_asset)
Asset 1099519242825: creekdrops21 -   Bitcoin #1/21 (Max Supply: 21)
>>>
>>> # get link to asset's primary image
>>> print(my_asset.image)
https://ipfs.io/ipfs/QmUn8kvvHFrJK2mSsiPFNRMmmehnRoNJsqTP4XTVsemgrc
>>>
>>> # get asset collection, which is a Collection object
>>> collection = my_asset.collection
>>> print("Author:",collection.author)
Author: creek.gmRetrieving assets based on criteriaTo get assets based on some criteria, you can useAtom.get_assets, which will return a list based on criteria passed. Currently,get_assetsaccepts owner, template, schema, and/or collection as either strings or Class Objects.>>> # Get assets using owner and template as strings
>>> assets = atom.get_assets(owner="someowner123", template = "12345")
>>>
>>> # Get assets using collection class object
>>> assets = atom.get_assets(collection=my_asset.collection)DocumentationFull documentation is being assembled atRead the Docs.ContributingSeeContributing.Alternatively, if you would like to sponsor me, consider donating some WAX to the addressdaltonpython.AttributionWAX teamfor development of the WAX blockchain.Pink.networkfor development of atomic assets.PurpleBoothfor Contributing Template.Contact meTwitter:@stuckat6pm
Package: daltonlens
DaltonLens-PythonThis python package is a companion to the desktop applicationDaltonLens. Its main goal is to help the research and development of better color filters for people with color vision deficiencies. It also powers the Jupyter notebooks used for the technical posts ofdaltonlens.org. The current features include:Simulate color vision deficiencies using the Viénot 1999, Brettel 1997 or Machado 2009 models.Provide conversion functions to/from sRGB, linear RGB and LMSImplement several variants of the LMS modelGenerate Ishihara-like test imagesFor a discussion about which CVD simulation algorithms are the most accurate see ourReview of Open Source Color Blindness Simulations.For more information about the math of the chosen algorithms see our articleUnderstanding CVD Simulation.Installpython3 -m pip install daltonlensHow to useFrom the command linedaltonlens-python --help
usage: daltonlens-python [-h] 
       [--model MODEL] [--filter FILTER]
       [--deficiency DEFICIENCY] [--severity SEVERITY]
       input_image output_image

Toolbox to simulate and filter color vision deficiencies.

positional arguments:
  input_image           Image to process.
  output_image          Output image

optional arguments:
  -h, --help            show this help message and exit
  --model MODEL, -m MODEL
                        Color model to apply: vienot, brettel, machado or auto (default: auto)
  --filter FILTER, -f FILTER
                        Filter to apply: simulate or daltonize. (default: simulate)
  --deficiency DEFICIENCY, -d DEFICIENCY
                        Deficiency type: protan, deutan or tritan (default: protan)
  --severity SEVERITY, -s SEVERITY
                        Severity between 0 and 1 (default: 1.0)From codefromdaltonlensimportconvert,simulate,generateimportPILimportnumpyasnp# Generate a test image that spans the RGB rangeim=np.asarray(PIL.Image.open("test.png").convert('RGB'))# Create a simulator using the Viénot 1999 algorithm.simulator=simulate.Simulator_Vienot1999()# Apply the simulator to the input image to get a simulation of protanomalyprotan_im=simulator.simulate_cvd(im,simulate.Deficiency.PROTAN,severity=0.8)
Package: dalymi
dalymi[data like you mean it]A lightweight, data-focused and non-opinionated pipeline manager written in and for Python.dalymiallows to build data processing pipelines asdirected acyclic graphs(DAGs) and facilitates rapid, but controlled, model development. The goal is to prototype quickly, but scale to production with ease.
To achieve this,dalymiuses "make"-style workflows,i.e.tasks with missing input trigger the execution of input-producing tasks before being executed themselves. At the same time,dalymiprovides fine control to run and undo specific pipeline parts for quick test iterations. This ensures output reproducability and minimizes manual errors.Several features facilitatedalymi's goal:simple, non-opinionated API (most choices left to user)no external dependencies for pipeline executionone-line installation (ready for use)no configurationauto-generated command line interface for pipeline executionquick start, but high flexibility to customize and extend:task output can be stored in any format Python can touch (local files being the default)customizable command line argumentstemplated output location (e.g. timestamped files)support for automated checks on data integrity during runtimeDAG visualization usinggraphvizAPI design encourages good development practices (modular code, defined data schemas, self-documenting code, easy workflow viz, etc.)Installationdalymirequires Python >= 3.5.pipinstalldalymiFor the latest development:pipinstallgit+https://github.com/joschnitzbauer/dalymi.gitDocumentationhttp://dalymi.readthedocs.io/Simple examplesimple.py:fromdalymiimportPipelinefromdalymi.resourcesimportPandasCSVimportpandasaspd# Define resources:numbers_resource=PandasCSV(name='numbers',loc='numbers.csv',columns=['number'])squares_resource=PandasCSV(name='squares',loc='squares.csv',columns=['number','square'])# Define the pipelinepl=Pipeline()@pl.output(numbers_resource)defcreate_numbers(**context):returnpd.DataFrame({'number':range(11)})@pl.output(squares_resource)@pl.input(numbers_resource)defsquare_numbers(numbers,**context):numbers['square']=numbers['number']**2returnnumbersif__name__=='__main__':# Run the default command line interfacepl.cli()Command line:pythonsimple.pyrun# executes the pipeline. skips tasks for which output already exists.More examples can be foundhere.RoadmapMore docstringsUnit testsContinuous integrationParallel task processingREST API during pipeline runWeb interface for pipeline runWarrantyAlthoughdalymiis successfully used in smaller applications, it is not battle-tested yet and lacks unit tests. If you decide to use it, be prepared to communicate issues or fix bugs (it's not a lot of code... :)).Contributions... are welcome!
Package: dalys
Dalys - library for visualising data analysis algorithmsDalys - library that allows to visualize many algorithms that need for statistical data processing and machine learningGetting StartedDalys is a wrapper over the libraryscikit-learnand you can usescikit-learn datasetsfor visualize desired algorithm.Example:fromsklearn.datasetsimportmake_circlesfromdalys.kernel_pcaimportKPCAToolX,y=make_circles(n_samples=1000,random_state=123,noise=0.1,factor=0.2)style=[('red','.'),('blue','.')]label_names=['red dotes','blue dotes']kpca=KPCATool(X,y,style=style,labels_unique_name=label_names,n_components=3,kernel='rbf',gamma=2,scaled=True)kpca.projections_plot(grid=22)There is a number of parameters that can be set for the KPCATool class;
the major ones are as follows:style- set marker styles and colors for data representation,
example: style = [('red', '.'), ('blue', '.')] or
style = [('red', 'd'), ('blue', 'd')]. If you need random colors and markers - leave this argument with default parameter (default = None).labels_unique_name- set list with class names, such as labels_unique_name = ['red dotes', 'blue dotes']. Iflabels_unique_nameisNone,
this means that labels will be numbered in ascending order (default = None).preprocessing- for use data preprocessing, set this parameter to one of the following options (default = 'std'):std-standardize featuresnorm_l1-L1 normalizationnorm_l2-L2 normalizationminmax-MinMax scalermaxabs-MaxAbs scalerscaled- this flag need to control preprocessing of your data, if your data is allready processed, you must set "True".Installingpip install dalysAuthorsTimothy Tkachenko- Machine Learning Researcher
Package: dalysis
dalysis: for data analysisI often need to deal with Excel and CSV table files in the process of numerical calculation and data analysis. And this is a package I wrote for the convenience of my own calculation.If you find that there are some problems in this package, or there are functions and codes that need to be improved, please contact me or help me complete these. Thank you very much.Something About the packagethe tree of this packagedalysis
│table.py
│typecv.py
│__init__.pytable.pyThis module have functionstable.open_csvandtable.open_excelto  handles excel and csv and return a object whose type is <class 'table.Table'>typecv.pyThis module have functions for type conversation.A demo code:''' test data.csv:date,value1,value22020/1/11,1,62020/1/12,3,32020/1/13,2,12020/1/14,7,82020/1/15,3,32020/1/16,1,12020/1/17,6,662020/1/18,8,332020/1/19,4,652020/1/20,9,322020/1/21,22,42020/1/22,45,332020/1/23,2,52020/1/24,7,32020/1/25,8,72020/1/26,0,42020/1/27,4,8'''fromdalysisimporttablefromdalysisimporttypecvimportmatplotlib.pyplotasplttb=table.open_csv("test data.csv","r")tb.output()plt.plot(typecv.toDate(tb.head('date'),"%y/%m/%d"),tb.head('value1'))
Package: dam
# Discord App Manager![Built With Love :)](https://forthebadge.com/images/badges/built-with-love.svg)![Made with Python](https://forthebadge.com/images/badges/made-with-python.svg)![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)[![PyPi](https://img.shields.io/pypi/v/dam.svg)](https://pypi.org/pypi/dam/)A simple package for uploading and deleting Discord Rich Presence images.### Example```python3from dam import loginsession = login(email=EMAIL, password=PASSWORD)app = session.get_app(name="Listening to Music :)")image_id = app.upload_image('path/to/image.png')app.delete_image(image_id)```
Package: dam4ml
This is the dam4ml client library.Installationpip install dam4ml(Ugh, pretty is, uh?)Basic usagefromdam4mlimportclientfromdam4mlimporttransforms# Login to DAM4MLdataset=client.connect("mnist",api_key="")# (optional) Pre-load the whole dataset for offline performance.# This will take a while but will improve further performance.dataset.load()# (optional) You can pre-filter your dataset. See DAM4ML website# for more information about how to build your filterfilter={"tag_slug":"test",}# Iterate through all dataset itemsforitemindataset.as_dict(**filter):# ...process each dataset item here.pass# Convert dataset to a pynum arraydataset.as_pynum(**filter)# Even better, simulate what Keras' load_dataset() method would do:pn_dataset=dataset.as_pynum()(x_train,y_train)=pn_dataset[](x_val,y_val)=pn_dataset[]
Package: damagefunctions
Damage FunctionsThis library provides a suit of residential damage functions for facilitating flood risk assessment.The following functions are available:Damage functionRegions applicableApplicable building typologyReferenceCommentspistrika_US_2010_block_groupNew OrleansN/APristrika and Jonkman (2010)Based on Hurricane Katrina New Orleans residential damage data; Applicable for block groupspistrika_US_2010_blockNew OrleansN/APristrika and Jonkman (2010)Based on Hurricane Katrina New Orleans residential damage data; Applicable for blocks
Package: damagescanner
DamageScanner: direct damage assessments for natural hazardsA python toolkit for direct damage assessments for natural hazards. Even though the method is initially developed for flood damage assessments, it can calculate damages for any hazard for which you just require a vulnerability curve (i.e. a one-dimensional relation).Please note:This package is still in development phase. In case of any problems, or if you have any suggestions for improvements, please raise anissue.BackgroundThis package is (loosely) based on the original DamageScanner, which calculated potential flood damages based on inundation depth and land use using depth-damage curves in the Netherlands. The DamageScanner was originally developed for the 'Netherlands Later' project(Klijn et al., 2007).  The original land-use classes were based on the Land-Use Scanner in order to evaluate the effect of future land-use change on flood damages.InstallationRequirements:NumPy,pandas,geopandas,matplotlib,rasterio,tqdm,xarray,pyprojOpen the python environment in your command prompt or bash in which you want to install this package.Typepip install damagescannerand it should install itself into your python environment.Now you can import the package like any other package!OR:Clone the repository or download the package on your computer and extract the folder.Go to the DamageScanner folder in your command prompt or bash.Typepython setup.py installand it should install itself into your python environment.Now you can import the package like any other package!Create testing environmentRecommended option is to use aminicondaenvironment to work in for this project, relying on conda to handle some of the
trickier library dependencies.# Add conda-forge channel for extra packagescondaconfig--addchannelsconda-forge# Create a conda environment for the project and install packagescondaenvcreate-fenvironment.yml
activateds_envDocumentationPlease refer to theReadTheDocsof this project for the full documentation of all functions.How to cite:If you use theDamageScannerin your work, please cite the package directly:Koks. E.E. (2022). DamageScanner: Python tool for natural hazard damage assessments. Zenodo.http://doi.org/10.5281/zenodo.2551015Here's an example BibTeX entry:@misc{damagescannerPython,
          author       = {Koks, E.E.},
          title        = {DamageScanner: Python tool for natural hazard damage assessments},
          year         = 2022,
          doi          = {10.5281/zenodo.2551015},
          url          = {http://doi.org/10.5281/zenodo.2551015}
    }LicenseCopyright (C) 2022 Elco Koks. All versions released under theMIT license.
Package: damask-parse
damask-parseInput file writers and output file readers for the crystal plasticity code DAMASK.Installationpip install damask-parseRoadmapReaders:✅read_table️✅read_geom✅read_spectral_stdout✅read_spectral_stderr❌read_load✅read_materialWriters:✅write_geom✅write_load✅write_material_config✅write_numerics_configUtilities:✅get_header_lines✅get_num_header_linesExamplesRead an ASCII table fileThe following example will read in the data from an ASCII table file. By default, this function will re-combine array columns (which are split into their individual components in the text file) into Numpy arrays.fromdamask_parseimportread_tabletable_path='path/to/table/file.txt'table_data=read_table(table_path)
Package: damcalculator
damCalculatorA useful tool to calculate the dam's slidding and overturning safety factors, also can derive all the complicated forces applied to a single dam. The project is programmed in an object-oriented way, so most of the time when you want to pass parameters from one object to another, remember this "parameter" may also be an object.InstallationUse pip to install damCalculator:.. code:: bash
pip install damcalculatorExampleHere's an simple example of how to use this package on the St.Francis dam.Import some bascis packages:..code::python
from matplotlib import pyplot as plt
import damCalculatorPrepare for plotting:..code::python
fig,ax=plt.subplots()
plt.close(fig)Define some inner parameters of the St.Francis dam:..code::python
damGeometry=damCalculator.geometry.damGeometry(H=850.3048,h=1700.3048,l=150.3048,a=100.3048,b=1350.3048,c=300.3048,hu=2000.3048,hd=200.3048)
concrete=damCalculator.material.concrete(density=2400)
water=damCalculator.material.water(density=1000)The distribution of uplift water pressure, choose one from the two below, or you can create your own:..code::python
upliftForce=damCalculator.force.upliftForce(upliftPressure=[(0,598017.6,0)],damGeometry=damGeometry)
upliftForce=damCalculator.force.upliftForce(upliftPressure=[(0,0)],damGeometry=damGeometry)Create model instance:..code::python
model=damCalculator.model(damGeometry=damGeometry,concrete=concrete,water=water,upliftForce=upliftForce,fig=fig,ax=ax)Print overturning safety factor and slipping safety factor:..code::python
print(model.overtuningFactor.oFactor)
print(model.slipFactor.sFactor)Plot the shape of the dam..code::python
model.plotDam.showDam()ContributingPull 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.LicenseMIT
Package: dame
Dataflow Awesome Managing EngineThe easiest dataflow managing framework -currently under construction.DAME solves/facilitates:Building datasets from files / foldersTransforming data in the right orderSaving transformed data - once computed never compute it againChoosing the best transformation from a few configurationsGreat for working with numpy, pyTorch and more.VisionTechnically:Compute stages:Sources - get data elementTransforms - compute something out of available dataReducers - compute something on the whole datasetCombining data sourcesCompute only what you need - optimized performance via DAGsBackup and cache, after stages, support for custom serializersRanking various configurations(Optional) Parallel processingPriorities:Easy to useBatteries includedLittle overhead - take advantage of fastest tools availableIntegrates seamlessly with other toolsExpandableNice to have:Few python dependenciesIntegrate tqdmDAG outputBacklog:1.0.0:- Dataset - compute items via Sources and Transforms- Dataset - compute stage by stage, (assequence)- Dataset - validate Transforms- Dataset - (_Stages) DAG computations- Dataset - Automatic (Transform) versioning based on source and attrs- Workers - MultiThreading / MultiProcessing- Dataset - Building context for transforms- Storage - SQLite-WIP- Dataset - Enable Storage & Caching- Reducer - Scoring- Reducer - Ranking configurations, Find optimal parameters- Stages - Make an actual DAG instead of topsort- Cache - Ring- Dataset - Compute by chunks for efficient cache- Transform - Mapping Transform, Sequential transform- Transform - Delete intermediate result- Dataset - Autodelete unrequired objects form memory (Autosequential)- Docs - Dame tutorial & more tests- TODOS - Solve left todos from the codeStorage/Cache options:PickleJoblibRedisSqlitePyTablesParquet/Dask2.0.0 Ideas:Easy reuse Dame transforms in Luigi/Dask/Apache HadoopMore built-in storage and cache optionsBuilt-in datasets like torchvision.MNIST etcModule for managing on disk datasets. GUI? Conversion between:Pytorch ImageFolderImages + csvSome OtherDevelopment:- tox - build- tox - publish- hosting docs on readthedocs- tox - publish docs- coverage- badges