Saravanan666/pypi-org huggingface dataset:
Package: dflit
Warningdflitis a minor fork offlitand not intended for public
use.Please use the originalflitOriginal READMEFlitis a simple way to put Python packages and modules on PyPI.
It tries to require less thought about packaging and help you avoid common
mistakes.
SeeWhy use Flit?for
more about how it compares to other Python packaging tools.Install$ python3 -m pip install flitFlit requires Python 3 and therefore needs to be installed using the Python 3
version of pip.Python 2 modules can be distributed using Flit, but need to be importable on
Python 3 without errors.UsageSay you’re writing a modulefoobar— either as a single filefoobar.py,
or as a directory — and you want to distribute it.Make sure that foobar’s docstring starts with a one-line summary of what
the module is, and that it has a__version__:"""An amazing sample package!"""__version__='0.1'Install flit if you don’t already have it:python3 -m pip install flitRunflit initin the directory containing the module to create apyproject.tomlfile. It will look something like this:[build-system]requires=["flit_core >=2,<4"]build-backend="flit_core.buildapi"[tool.flit.metadata]module="foobar"author="Sir Robin"author-email="robin@camelot.uk"home-page="https://github.com/sirrobin/foobar"You can edit this file to add other metadata, for example to set up
command line scripts. See thepyproject.toml pageof the documentation.If you have already got aflit.inifile to use with older versions of
Flit, it will still work for now, but you should convert it topyproject.tomlwhen convenient.Run this command to upload your code to PyPI:flit publishOnce your package is published, people can install it usingpipjust like
any other package. In most cases, pip will download a ‘wheel’ package, a
standard format it knows how to install. If you specifically ask pip to install
an ‘sdist’ package, it will install and use Flit in a temporary environment.To install a package locally for development, run:flit install [--symlink] [--python path/to/python]Flit packages a single importable module or package at a time, using the import
name as the name on PyPI. All subpackages and data files within a package are
included automatically.
Package: dflow-galaxy
DFlow GalaxyCollection of workflows and tools built on top of DFlow andai2-kit.FeaturesDFlowBuilder: A type friendly wrapper forDFlowto build workflows in a more intuitive way.Workflows:TESLA (under development): aTraining-Exploration-Screening-Labeling workflow designed byAI4EClab. Get inspired byDPGEN,DPGEN2, ported fromai2-kit.Get Starteddflow-galaxyrequires Python 3.9+ since it depends ontyping.Annotated.To usedflow-galaxyas a library, you can install it via pip:pipinstalldflow-galaxyFor developers, please usepoetryto bootstrap the development environment:poetryinstall
poetryshellManualsTESLA Workflow
Package: dflow-hello
dflow-hellodflow demo OPThis OP is the default output of thedflow OP cutter,
intended to help developers get started with their dflow OPs.Repository contents.github/:Github Actionsconfigurationci.yml: runs tests at every new commitpublish-on-pypi.yml: automatically deploy git tags to PyPI - just generate aPyPI API tokenfor your PyPI account and add it to thePYPI_API_TOKENsecret of your github repositorypublish-on-dockerhub.yml: automatically build docker image and push to Docker Hub - just add theDOCKER_USERNAMEandDOCKER_PASSWORDsecrets of your github repositorydflow_hello/: The main source code of the OP packageexamples/: An example of how to submit a workflow using this OPtests/: Basic regression tests using thepytestframework.VERSION: Current versionDockerfile: Dockerfile for building docker image.gitignore: Telling git which files to ignoreLICENSE: License for your OPREADME.md: This filepyproject.toml: Python package metadata for registration onPyPIInstallationpipinstalldflow-hello
Package: dflow-refiner
dflow_refinerDflow OP library to integrate multi-calculators for high-throughput molecule screening.This OP library constructed bydflow OP cutter.Repository contents.github/:Github Actionsconfigurationpublish-on-pypi.yml: automatically deploy git tags to PyPI when version changeddflow_refiner/: The main source code of the OP package.refiner_gym/: Place to exercise with dflow_refiner.unit_test/: unit test for some key components.tutorial_VASP/: Tutorial to build a refiner, VASP refiner for example.examples/: Examples to use dflow_refiner library.miniAutoSteper/: Simplified version ofAutoSteperconformation_search_test/: Automated conformation search withdflow_refinerVERSION: Current version.gitignore: Telling git which files to ignoreLICENSE: License for your OPREADME.md: This filepyproject.toml: Python package metadata for registration onPyPIInstallationpipinstallpydflow,ase,pandas
pipinstalldflow-refiner
dockerpullfranklalalala/py_autorefinerContact meE-mail:1660810667@qq.com
Package: df-magic-openSARlab
df_magic_openSARlab%dfmagic commands to get file usage within OpenSARlab. This package utilizes python functionshutil.disk_usage().RequirementsJupyterLab >= 3.0Python >= 3.6InstallTo install this package, execute:pip install df_magic_openSARlabUninstallTo remove the package, execute:pip uninstall df_magic_openSARlabHow to UseYou must first import the package by running following command:importdf_magic_openSARlabThen, you may use one of the following commands:%dfreturns a human readable string in GB. Input is the path to the disk/partition. Default is '/home/jovyan'.%df --rawreturns a raw data object.%df --onreturns rsults in a string in GB after every subsequent cell run.%df --offturns offon.%df -p /sets the path to the partition to check.%df -vprints off additional text for debugging.
Package: df-magic-test
df_magic_test%dfmagic commands to get file usage within OpenSARlab. This package utilizes python functionshutil.disk_usage().RequirementsJupyterLab >= 3.0Python >= 3.6InstallTo install this package, execute:pip install df_magic_testUninstallTo remove the package, execute:pip uninstall df_magic_testHow to UseYou must first import the package by running following command:importdf_magic_testThen, you may use one of the following commands:%dfreturns a human readable string in GB. Input is the path to the disk/partition. Default is '/home/jovyan'.%df --rawreturns a raw data object.%df --onreturns rsults in a string in GB after every subsequent cell run.%df --offturns offon.%df -p /sets the path to the partition to check.%df -vprints off additional text for debugging.
Package: dfmock
DFMockpandas dataframe mocker for python3.Why?Sometimes you just need mock data that is already in pandas datatypes. There are lots of data gen tools out there, but most produce CSVs or some such that needs to be consumed by pandas; this adds a volitile point to your tests.What if your logic is correct, but the datatypes didn't import correctly from the CSV?So DFMock aims to generate mock dataframes where the datatypes are controlled.InstallationUse pippip install dfmockYou can also get the sourcehereThe APIusing is simple.
import into your module, select your column names and data types, set the number of columns, and generate your frame.
from dfmock import DFMockcolumns = { "hamburger":"string",
            "hot_dog":"integer",
            "shoelace":"timedelta"
          }
dfmock = DFMock(count=100, cols=columns)
dfmock.generate_dataframe()

my_mocked_dataframe = dfmock.dataframePandas data types supported:PANDAS TYPEDICT VALUEobjectstringint64intfloat64floatboolbooldatetime64datetimetimedeltatimedeltacategorycategoryso to make a dataframe with column "banana" that is anint64and "rockstar" that is acategorytype:dfmock.cols = {"banana":"int","rockstar":"category"}pretty simple.Grow to Sizesometimes you need your dataset to be a certain memory size instead of row size. Thegrow_dataframe_to_size()allows you to grow a frame until it reaches or passes the given size (in MB).
Need a 10MB dataframe?dfmock.generate_dataframe()
dfmock.size
## returns 0.2 MB

dfmock.grow_dataframe_to_size(10)
dfmock.size
## returns ~10 MBGroupingNOTE:timedeltaandcategorydatatypes are not currently supported.
Sometimes you need a column you can aggregate on with a given data type. For example, you may want 1M rows with one of 4 datetime values (maybe representing 4 observation reporting timestamps?). You can do this usinggrouping.
a grouped column is declared by passing a dict as the data type value with the params for the grouped column as keys. Like this:columns = {"amazing_grouped_column_with_3_values": { "option_count":3, "option_type":"string"}}This will give you a column with only 3 distinct values and (nearly) equal distribution.
If you need to control the distribution you can pass the histogram argument. This is useful if, for instance, you want a dataset with 4 datetime values and want one value for 50% of records, another for 30%, and the remaining values 20%. You would delcare this distribution like so:columns = {"super_cool_grouped_column_with_histogram": {"option_count":4, "option_type":"datetime","histogram":(5,3,2,2,)}}The integers you pass histogram need to add up to 10 with the same number of values as option count (ie. ifoption_count= 5, you need 5 values). This caps option count at 10 currently for histogram.
Your desired row count must also be divisible by 10 - this keeps the math simple.ContributionWe welcome pull requests!
Package: dfmt
Overviewdfmt is a Python command line tool that can reformat text, allowing you to go from:this is a pretty big sentence with lots of words that takes a lot of horizontal spaceto:this is a pretty big sentence with lots
of words that takes a lot of horizontal
spaceIt can also be used to format paragraphs in comments and doc strings.Input:/**
 * This is a very long line in a Doxygen comment that takes a lot of space
 */Output:/**
 * This is a very long line in a
 * Doxygen comment that takes a lot of
 * space
 */InstallationThe recommended way is to usepipxto installdfmt. You can also usepipdirectly if you know
what you are doing.UsageSend the text to stdin, and dfmt will write the results to stdout.By default, text is wrapped at 80 characters. You can use the-w,–widthoption to set a different size.As such,dfmtcan be used in a number of text editors.How it worksdfmt contains an hard-coded list of known prefixes.It will start by splitting the input in “regions” that start with the same
prefix.Then it will use thetextwrapmodule from the Python standard library
to wrap each region while keeping the existing prefix.
Package: dfm-tools
dfm_toolsA Python package for pre- and postprocessing D-FlowFM model input and output files. Contains convenience functions built on top of other packages likexarray,xugrid,hydrolib-coreand many more.Informationinstall withpip install dfm_tools -U(orinstallation guide)online documentationwith installation guide, tutorials/examples, API reference and contributing guide.Bug or feature request? Create aGitHub issue
Package: dfn-pki-client
DFN-PKI-ClientExample#!/usr/bin/env python

from dfn_pki_client.public_service import PublicServicePKI
from dfn_pki_client.registration_service import RegistrationService
from dfn_pki_client.utils import get_wsdl


def main():

    pki = PublicServicePKI('config.ini')

    ca_info = pki.get_ca_info(42)

    print(ca_info)


if __name__ == '__main__':
    main()InstallationLinux (e.g. Ubuntu)apt install openssl rustc
pip3 install cryptography pyopenssl suds-community urllib3macOSbrew install openssl swig rustup
pip3 install cryptography pyopenssl suds-community urllib3Windows (untested)pip3 install cryptography pyopenssl suds-community urllib3SetupCreate the configuration fileconfig.ini[default]
cert = file_name.p12
password = 0123456789
public_wsdl = https://pki.pca.dfn.de/<ca_name>/cgi-bin/pub/soap?wsdl=1
registration_wsdl = https://ra.pca.dfn.de/<ca_name>/cgi-bin/ra/soap?wsdl=1
domain_wsdl = https://ra.pca.dfn.de/<ca_name>/cgi-bin/ra/soap/DFNCERT/Domains?wsdl=1'
Package: dfoalgos
DescriptionThis package contains derivative-free optimization algorithms. With the
exception of NMK, the included algorithms are even “rank-based” algorithms,
which do not use the actual objective values, but only their ranks. Thus, they
do not require objective values to be scalar and finite. A total order on the
objective values is sufficient. For example, an objective function could
return a list of values, which are then compared lexicographically. The
package can only handle bound constraints explicitly. For other constraints,
infeasible solutions should instead be penalized, e.g., evaluated with the
worst possible function value (possibly infinity).The package is geared to work with optimization problems as defined in the
package optproblems. The whole package assumes minimization problems
throughout.DocumentationThe documentation is located athttps://www.simonwessing.de/dfoalgos/doc/
Package: dformpy
This Python library deals with differential forms. It gives an interactive visualisation of differential forms and their exterior algebra, exterior derivative, interior derivative, wedge product and the Hodge star operation. The library also plots contravariant vector fields and their different geometric features such as gradient, divergence and curl.The library has been published via a research paper. The paper gives detailed explanation of the library structure, plenty of examples and potential future implementations to the library ... The publication can be found here https://arxiv.org/abs/2201.10517Change Log========1.0 (15/1/2022)- First Release---------------------------------------------------------------1.0.1 (15/1/2022)-  Technical fix. Changes to the __init__.py.   No new implementations---------------------------------------------------------------1.0.2 (30/1/2022)-  A fix to the zooming insets. The parameters for the boolean 'inset' are now set to True. No new implementations
Package: dfp
# DFP: Dogmatic Functional Programming[![Documentation Status](https://readthedocs.org/projects/dogmatic-functional-programming/badge/?version=latest)](https://dogmatic-functional-programming.readthedocs.io/en/latest/?badge=latest)
[![Coverage Status](https://coveralls.io/repos/github/jaypmorgan/dfp/badge.svg?branch=main)](https://coveralls.io/github/jaypmorgan/dfp?branch=main)
![PyPI](https://img.shields.io/pypi/v/dfp?label=dfp)
![PyPI - Downloads](https://img.shields.io/pypi/dm/dfp)Procedures to help with help with functional-styles in the Python programming language.## InstallationDFP can be installed from PyPI:`bash pip install dfp `After which, you import it:`python import dfp `## User guideFor a full API list and other user guides, please consult <https://dogmatic-functional-programming.readthedocs.io/>
Package: dfpercentile-pkg-chanrl
df_percentile PackageBackgroundThis package can split a Pandas Dataframe into two groups by a specified percentile and column to split on.It can be useful for identifying trends in data sets with features such as price or salary.
E.g. in a NYC rent listing database with the following columns: price, bedrooms, bathroomsIn [7]: df.head()

Out[7]: 
   bedrooms  bathrooms  latitude  longitude  price
0         3        1.5   40.7145   -73.9425   3000
1         2        1.0   40.7947   -73.9667   5465
2         1        1.0   40.7388   -74.0018   2850
3         1        1.0   40.7539   -73.9677   3275
4         4        1.0   40.8241   -73.9493   3350If you split the df by price, the scatter method can help you visualize the distribution of features such as bathrooms and bedrooms for the higher rent vs lower rent group.
The create_df will run a ttest on the two groups and whichever columns you specified as you instantiated the object, returning p-values with the means of the features.
It can also bootstrap from the two groups and create a histogram of the distribution of sample means, along with the 95% confidence intervals.InstructionsFirst initialize the object with:df_percentile(df, col_names, col_to_separate)bedrooms and bathrooms are the features you care about, separate by priceIn [12]: new_df = df_percentile(df, ['bedrooms','bathrooms'], 'price')
This dataframe is separated by pricecreate_df(percentile)p-values were very small for the two groups when you split the rent price by the top 30 percentileIn [13]: new_df.create_df(70)

Out[13]: 
           p-values  upper_bound_means  lower_bound_means
bedrooms        0.0           2.319909           1.159946
bathrooms       0.0           1.522683           1.030201bootstrap(percentile, col_name, n_simulations = 10000, ci = 95)In [16]: new_df.bootstrap(70, 'RAA')    
# was used in a project of mine for splitting MLB relief pitchers by salary and measuring the group performancebootstrap_stats()In [6]: data.bootstrap_stats()

      The 95% confidence intervals for the upper bound group ranges from -1.1944029850746265 to 2.716417910447761.
      The lower bound group ranges from -2.529032258064516 and -0.44516129032258067.
      Means of the distribution: 
      Upper Bound Group: 0.7459731343283582
      Lower Bound Group:-1.4869800000000002corr(percentile, col_name)In [25]: new_df.corr(95, 'bathrooms')

For the lower bound group: 
The correlation coefficent is 0.5437659981793554 and the p-value is 0.0
For the higher bound pitcher group: 
The correlation coefficent is 0.03580173165337624 and the p-value is 0.07722030909098343scatter(percentile, col_name)In [39]: new_df.scatter(80, 'bedrooms')
Package: df-permission
DFPermissionInstallationpip install df-permissionConfigurationINSTALLED_APPS = [...,'df_permission']Generate permissionsFor model fields:./manage.py generate_model_field_permissionsFor serializer fields (not include model fields):./manage.py generate_serializer_field_permissionsAttributesdf_methodMethod of actionValid values arecreate,update,retrieve,list,destroyclass MyView(CreateAPIView):permission_classes = [DFPermission]df_method = 'create'...orclass MyView(CreateAPIView):permission_classes = [DFPermission]df_method = DFMethods.CREATE...df_modelModelclass MyView(CreateAPIView):permission_classes = [DFPermission]df_model = MyModel...df_fieldsFieldsclass MyView(CreateAPIView):permission_classes = [DFPermission]df_fields = ['field1', 'field2', ...]...df_permissionsPermissionstype:string,list,tupleclass MyView(CreateAPIView):permission_classes = [DFPermission]df_permissions = ['permission1', 'permission2', ...]...orclass MyView(CreateAPIView):permission_classes = [DFPermission]df_permissions = 'permission1'...df_allow_superuserAllow superuser if value is TrueType:booleanDefault:FalseMethodsget_df_permissionsCustomize df_permissionsclass MyView(CreateAPIView):permission_classes = [DFPermission]def get_df_permissions(self):# write your logic codereturn # single permission or permissionsHow does it work?First, finddf_permissionsattribute. If it
does not exist, findget_df_permissionsmethod.
If it does not exist too, generate permissions.First for this, collect fields that are permission
required. Finddf_fields, if it exist. Else get
serializer class to get fields and get intersection
with model fields.Then, generate required perms using fields anddf_method.Finally, user's permissions are checked.
Package: df-pipeline
Dialog Flow PipelineDialog Flow Pipelineis python module add-on forDialog Flow Framework, a free and open-source software stack for creating chatbots, released under the terms of Apache License 2.0.Dialog Flow Pipelineallows you to ...Quick StartInstallationpipinstalldf_pipelineBasic exampleTo get more advanced examples, take a look atexampleson GitHub.Contributing to the Dialog Flow PipelinePlease refer toCONTRIBUTING.md.
Package: df-preprocessor
pre-processing tools for dataframes:Install pandas, numpy and plyer packagesInstall package (pip install df_preprocessing)Functions:Import csvExport csvExport Excel... (nog aan te vullen met correcte functienamen + korte omschrijving.)Also, automatische documentatie via docstrings eventueel binnentrekken?Doe dat maar met chatgpt: prompt: write me a readme.md file for this documentation:
Package: dfpwm
DFPWMDFPWM convertor for PythonInstallationFrom PyPIYou can get this package from PyPI
if you are in py311 Linux x86pipinstalldfpwmBuild from sourceUsagefrompathlibimportPathimportsoundfileassf# for reading audioimportdfpwmdata,sample_rate=sf.read('./someaudio.mp3')# read audio# If sample rate is not 48000, may get strange result# use `dfpwm.resample(...)` to resampleifsample_rate!=dfpwm.SAMPLE_RATE:raiseValueError(f"{sample_rate}!={dfpwm.SAMPLE_RATE}")iflen(data.shape)!=0anddata.shape[1]>1:data=data[:,0]# get channel 0dfpwm=dfpwm.compressor(data)# convertPath('out.dfpwm').write_bytes(dfpwm)# write result to fileBuild from sourceClonegitclonehttps://github.com/CyanChanges/python-dfpwm.gitpython-dfpwmcdpython-dfpwmBuildThis project usepoetryto build,
Make surepoetryis installed.poetrybuild
Package: df-qwerty
Dialog Flow EngineThe Dialog Flow Engine (DFE) allows you to write conversational services. The service is written by defining a special dialog graph that describes the behavior of the dialog service. The dialog graph contains the dialog script. DFE offers a specialized language (DSL) for quickly writing dialog graphs. You can use it in such services for writing skills for Amazon Alexa and etc, chat-bots for social networks, websites call-centers and etc.Quick StartInstallationpipinstalldf_engineBasic examplefromdf_engine.core.keywordsimportGLOBAL,TRANSITIONS,RESPONSEfromdf_engine.coreimportContext,Actorimportdf_engine.conditionsascndfromtypingimportUnion# create script of dialogscript={GLOBAL:{TRANSITIONS:{("flow","node_hi"):cnd.exact_match("Hi"),("flow","node_ok"):cnd.true()}},"flow":{"node_hi":{RESPONSE:"Hi!!!"},"node_ok":{RESPONSE:"Okey"},},}# init actoractor=Actor(script,start_label=("flow","node_hi"))# handler requestsdefturn_handler(in_request:str,ctx:Union[Context,dict],actor:Actor):# Context.cast - gets an object type of [Context, str, dict] returns an object type of Contextctx=Context.cast(ctx)# Add in current context a next request of userctx.add_request(in_request)# pass the context into actor and it returns updated context with actor responsectx=actor(ctx)# get last actor response from the contextout_response=ctx.last_response# the next condition branching needs for testingreturnout_response,ctxctx={}whileTrue:in_request=input("type your answer: ")out_response,ctx=turn_handler(in_request,ctx,actor)print(out_response)When you run this code, you get similar output:type your answer: hi
Okey
type your answer: Hi
Hi!!!
type your answer: ok
Okey
type your answer: ok
OkeyTo get more advanced examples, take a look atexampleson GitHub.Contributing to the Dialog Flow EnginePlease refer toCONTRIBUTING.md.
Package: dfr
dfrduplicacy-finder-removerDFRisDuplicacy Finder Remover, A command-line tool find locate remove and manage duplicacies in files.InstallationInstall using pip (Recommended)Use pip to install, user--userflagpython3 -m pip install --user dfrBuild from SourceClone the repository and checkout to stable commitgit clone https://github.com/srbcheema1/dfr
cd dfr
git checkout <latest_version say: v0.0.x>install requirementspython3 -m pip install --user -r requirements.txtInstall Dfrpython3 setup.py install --userBuilding Source Distributionpython3 setup.py sdistContact / Social MediaDevelopment byDeveloper / Author:Srb CheemaDeveloper / Author:Rakesh Kumar
Package: dframeio
dataframe-ioRead and write dataframes from and to any storage.Documentation:https://chr1st1ank.github.io/dataframe-io/License: Apache-2.0Status: Initial developmentFeaturesDataframes types supported:pandas DataFramePython dictionarySupported storage backends:Parquet filesPostgreSQL databaseMore backends will come. Open anissueif you are interested in a particular backend.Implementation status for reading data:StorageSelect columnsFilter rowsMax rowsSamplingDrop duplicatesParquet files✔️✔️✔️✔️✔ ¹PostgreSQL✔️✔️✔️✔️✔️¹ only for pandas DataFramesImplementation status for writing data:Storagewrite appendwrite replaceParquet files✔️✔️PostgreSQL✔️✔️Installationpip install dframeio

# Including pyarrow to read/write parquet files:
pip install dframeio[parquet]

# Including PostgreSQL support:
pip install dframeio[postgres]Show installed backends:>>> import dframeio
>>> dframeio.backends
[<class 'dframeio.parquet.ParquetBackend'>]