Saravanan666/pypi-org huggingface dataset:
Package: fel
FelFel is a tool for submittingstacked diffsto GitHub. Fel takes care of all the busy work of submitting multiple commits as
a stack of PRs and lets you focus on keeping your diffs reviewable and lets reviewers
focus on understanding your code. When your stack is ready to land, Fel handles merging
all your PRs through GitHub, producing a commit history that looks like you rebased
the whole stack at once, without polluting your history with extra merge commits,
or requiring the upstream project to use an external tool to land diffs to master.DemoFel even generates graphs for your PRs to indicate all of the diffs in your stack
and how they relate.This diff is part of afel stack*#75 Bugfixes in file 4*#74 Added file4| *#73 New line in third file|/  
*#72 Third new file*#71 Line 1 in new file* masterUsageFel requires a GitHub oauth token to create and merge PRs on your behalf. Generate
onehere. Once you have your token, add it
to the Fel configuration file (default~/.fel.yml).gh_token:<your_token_here>Now create a new branch and start writing some diffs. Working with stacked diffs
requires a different way of thinking, think of each commit as an atomic unit of
change. Commit early into the development of each diff and amend often. Leave
detailed commit bodies, they'll become the contents of your PRs when you submit
your stack for review.Once your stack is ready, runfel submit. Fel will generate a PR for each commit
in the stack, basing the first PR againstorigin/master, and then each subsequent
PR against the previous PR in the stack. If multiple stacks overlap, Fel will
create a single PR for the common diffs, and base the diverging diffs on the common
base.When your diffs are reviewed and ready to land, checkout the top of your stack
and runfel land. Fel will merge the PRs on GitHub in order by rebasing onto
the base branch, without creating the ladder of merge commits associated
with a manual stacked PR workflow. After your commits are landed, fel cleans up
the branches it generated and leaves you on a fresh checkout of the upstream branch,
with all of your diffs landed.
Package: felapps
High-level application suite for free-electron laser, developed by PythonAuthor: Tong Zhang (zhangtong AT sinap dot ac dot cn)first uploaded to github on Apr. 23, 2015USAGE:pip install felappstype imageviewer in terminal to launch one of apps from felapps moduleORimport felappsfelapps.imageviewer.run()if config.xml not found in present working directory, please choose right config.xml file as the app guiding.
Package: felia
Felia关于felia是一个方便执行终端命令的工具，配合Pycharm Python console一起使用(其他Jetbrains系列IDE开发工具也可以, 下载python插件)，利用其强大的智能补全特性，提高命令输入效率。该库被设计成在Windows系统使用, 本地在wsl环境下执行命令, 同时也可以远程至其他主机执行命令。安装pip install felia快速上手打开Pycharm的Python控制台。一般情况下Python控制台会默认打开, 也可在菜单栏中调用:工具->Python或调试控制台执行代码>>> from felia.pip import *
>>> pip_list()
INFO $ pip list
Package                Version             
---------------------- --------------------
.......                ........已实现的命令行工具cobradockergopipprotocsphinxssh
Package: felimination
feliminationThis library contains some useful scikit-learn compatible classes for feature selection.FeaturesRecursive Feature Elimination with Cross Validation using Permutation ImportanceRequirementsPython 3.7+NumPyScikit-learnPandasInstallationIn a terminal shell run the following commandpip install feliminationUsagefromfelimination.rfeimportPermutationImportanceRFECVfromsklearn.linear_modelimportLogisticRegressionfromsklearn.datasetsimportmake_classificationimportnumpyasnpX,y=make_classification(n_samples=1000,n_features=20,n_informative=6,n_redundant=10,n_clusters_per_class=1,random_state=42,)selector=PermutationImportanceRFECV(LogisticRegression(),step=0.3)selector.fit(X,y)selector.support_# array([False, False, False, False, False, False, False, False, False,#        False, False,  True, False, False, False, False, False, False,#        False, False])selector.ranking_# array([9, 3, 8, 9, 7, 8, 5, 6, 9, 6, 8, 1, 9, 7, 8, 9, 9, 2, 4, 7])selector.plot()It looks like5is a good number of features, we can set the number of features to select to 5 without need of retrainingselector.set_n_features_to_select(5)selector.support_# array([False,  True, False, False, False, False,  True, False, False,#        False, False,  True, False, False, False, False, False,  True,#         True, False])LicenseThis project is licensed under the BSD 3-Clause License - see the LICENSE.md file for detailsAcknowledgmentsscikit-learn
Package: felips-counter
Felips-CounterDescriptionCount your project lines easily!InstallationRunpip install felips-counterin your terminal (asadministrator).Note: Make sure thecounterscript orPython Scriptsis in yourPATHsystem variable, in the Environment Variables.ExecutingAfter installation, open a terminal and runcounteron your project path.Ex.:C:\Users\PC\Documents\MyProject> counterNote: Runcounter -horcounter --helpto see all features..counterignorefile example:# Paths
/.idea
/__pycache__
/node_modules
/dist
/build
/out
/assets
/coverage
/.vscode

# Files
.gitignore
.env.local

# File extensions
*.lock
*.envDevelopment environmentIDEPackage managerVersion control systems2022 Felipe Pereira
Package: felisaparser
Convert Excel to CSV fileThis project's aim consists of a library calledfelisaparserto convert an Excel file to CSV file. It is based on the Pandas Library and it consists of a class made up by just one method:excel_to_csv().
This parser, unlike the Pandas Method, directly dumps the data into a CSV file, without the need of loading a DataFrame and occupy memory.Installingpip install felisaparserUsage>>> from felisaparser import parser
>>> parser('Filename.xlsx', ';').excel_to_csv()
Package: felis-python1
Supplementary material, lecture notes and exercises for the Python I
lecture at University of Freiburg.InstallationBasically, all lectures are in the.ipynbformat of version 4.
Therefore you need Jupyter to view them. One would need no installation,
in case the notebooks run without errors. In case the dependencies shall
be installed, this module can be installed using setuptools.~$gitclonehttps://github.com/mmaelicke/felis_python1.git~$cdfelis_python1~$pipinstall-rrequirements.txt~$cdlectures~$jupyternotebook
Package: felis-python2
Supplementary material, lecture notes and exercises for the Python II
lecture at University of Freiburg.This module will install all requirements needed for the lecture.InstallationBasically, all lectures are in the.ipynbformat of version 4.
Therefore you need Jupyter to view them. The most straitforward way to install the package
is using pip from your desired target environment like:pipinstallfelis_python2This will install the requirements and the lecture notes to thesite-packagesfolder of the target
Python environment. The module does include some auxiliary functions to use the notebooks from there.
Alternatively, it can also be downloaded from github and installed manually like:~$gitclonehttps://github.com/mmaelicke/felis_python2.git~$cdfelis_python2~$pipinstall-rrequirements.txt~$cdlectures~$jupyternotebookUsageThere are also two auxiliary functions included in the package. If installed using pip,felis_python2can
be imported. Therunfunction will start a Jupyter notebook server at the correct location and open a browser.
Thecopyfunction takes a path and will copy the lecute notes notebooks to that specific path.fromfelis_python2importrun,copy# to copy the notebooks to another locationcopy('my/new/location')# to run them from the site-packagesrun()
Package: felixlib
felixlibcommon functions collected
@author:spectereye@gmail.comFeaturesInstallpip install felixlibUsageDocumentationDisclaimer|---------------------------------------------------------------------------|
|DISCLAIMER:                                                                |
|THE SOFTWARE IS PROVIDED "AS IS",                                          |
|WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,                          |
|INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,            |
|FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.                      |
|IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,|
|DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,              |
|TORT OR OTHERWISE, ARISING FROM,                                           |
|OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR                    |OTHER DEALINGS IN THE SOFTWARE.
Package: felixlibrary
This is a library for the NYU Data Engineering Class (Part of Max's Code)Installpip install felixlibraryExample of Currency_pairs:currency_pairs = [["AUD","USD",[],portfolio("AUD","USD")],
["GBP","EUR",[],portfolio("GBP","EUR")],
["USD","CAD",[],portfolio("USD","CAD")],
["USD","JPY",[],portfolio("USD","JPY")],
["USD","MXN",[],portfolio("USD","MXN")],
["EUR","USD",[],portfolio("EUR","USD")],
["USD","RUB",[],portfolio("USD","RUB")],
["USD","CZK",[],portfolio("USD","CZK")],
["USD","PLN",[],portfolio("USD","PLN")],
["USD","INR",[],portfolio("USD","INR")]]Change Log0.0.1 (11/05/2022)-First Release
Package: felix-muia009
In this Python Package, i have defined 4 functions namely:
1.add-This function returns the sum of two intergers
2.sub -This function returns the difference  of two intergers
3. mul -This function returns the product  of two intergers
4. divide -This function returns the quotient of two intergersThe above functions need to been  as defined otherwise one gonna an error when trying to use any of the above  functionsnote:
Additionly the 4 modules are Together packed in one root folder named Felo
users need to  import package Felo first to their working directory
i.eimport Felo as Fonce This is satisfield and before using any of the listed functions,
a user needs to import each individual function
i.efrom Felo import add as d
from Felo import sub as s
from Felo import mul as m
from Felo import devide as deAgain,when this is satisfield,one   can now go ahead and use the function accordingly for example
using  the function add to add two interger numbers  and store the result of this addition in my_resultmy_result=add(2, 5)
my_resultupon successfull import of theChange Log0.0.1(13/11/2022)First Release
Package: fellipems-csv-json-converter
File ConverterCSV / JSON converterprojectfuncao: Converte_JSONCSV(modo,sep)Converte um arquivo ou pasta de arquivos do formatoCSVparaJSON. a funcao possui as variaveis 'modo' (opcional),
'sep' (opcional) e 'Arq' (obrigatorio)Arq: um arquivo ou pasta (string). caso seja passado para a funcao um unico arquivo, este sera convertido. 
   Caso seja passada uma pasta, serao convertidos todos os arquivos do tipo compativel
   
       Obs.:os arquivos convertidos serao salvos na mesma pasta do arquivo original e com mesmo nome, sobrescrevendo 
       arquivos que eventualmente existam na pasta
   
   modo: o modo padrao de conversao e CSV para JSON (modo='csv2json'), porem caso seja passado o parametro 'json2csv' 
   na variavel 'modo', a conversao sera feita no sentido contrario
   
   sep : o separador padrao para o arquivo CSV sera ',' (virgula), porem um separador diferente pode ser especificado 
   atraves da variavel 'sep'pip install fellipems_csv_json_converter
0.1.8#csv_converter --help
Package: fellow-py
fellow-pyHuge thanks toemlovefor paving the way on using Bleak in a library used in implementing acustom bluetooth componentin HA. Any similarities my library may take to hers are not deliberate copying and pasting, but her library was an awesome example to follow and so my patterns were likely heavily influenced by her work.Also huge thanks tou/bobobaloogaon Reddit. They posted afantasticbreakdown of their discovery of how the Fellow kettle app talked to the kettle over BLE which enabled me to implement the logic in Python. Definitely standing on their shoulders here.fellow-py is a library for controlling Fellow bluetooth devices (of which I am only aware of one at this time). So, more precisely speaking, it is a library for controlling their Stagg EKG+ Kettle.This library currently supports connecting, turning on, setting the target temperature, turning off, and disconnecting. The library automatically subscribes to the 2a80 characteristic of the 1820 service on the kettle. The handler for the notifications the device sends to the connecting device will set the current and target temperature properties on the kettle object for the user to observe. The kettle object also implements a temperature graph that helps determine an average warming rate of the kettle. The purpose of this is to be able to identify if there's not enough water in the kettle. The library currently doesn't support device discovery, but it easily could in the near future. For now it simply implements a discover module that allows for obtaining a kettle given a mac address so as to instantiate the StaggEKGPlusKettle class.Usageimportasyncioimportfellowasyncdefmain()kettle=fellow.StaggEKGPlusKettle("MA:CA:DD:RE:SS:01")try:awaitkettle.connect()awaitkettle.turn_on()awaitasyncio.sleep(5)print(kettle.current_temperature,kettle.target_temperature)awaitkettle.set_target_temperature(206)awaitasyncio.sleep(2)print(kettle.current_temperature,kettle.target_temperature)awaitkettle.turn_off()awaitkettle.disconnect()if__name__=="__main__":loop=asyncio.get_event_loop()loop.run_until_complete(main())Tests coming soon :)
Package: fellowship
contract-test-frameworkcontains an implementation of contract testing in
Python with support for REST and gRPC. Under the package name fellowshipHow to use from consoleRESTIf you want to validate a REST API, run Fellowship in validate mode.
If your contracts follow the Jinja2 syntax, make sure that you give the path to
config.yaml in environment variablecontract_test_config.
You can see examples of contracts and config atexample_contract.json.
Request part of the contract specifies the endpoint to make the request to.
While everything under properties defines the JSON schema to validate against.
Fellowship validates these contracts against a meta-schema before it makes the
request.
Example of how to run from console:$fellowshipvalidatepath/to/contract_directory/To generate a contract in console, run in generate mode, with the following
syntax:: fellowship generate path_of_the contract_to_generate request_kwargs
expected_json.
Request_kwargs is the request as a dictionary, the dictionary can take following
parameters:url: can be given as a full url, or just the endpoint (/api/v1/test)it will then fill out the Jinja 2 syntax for you{{ config.protocol }}://{{ config.host}}/api/v1/test, when validatingprotocol and config will be filled from config.yamlheaders: can be given as a dictionary {“Accept”: “application/json”}, ifleft empty it will automatically fill as{{ config.default_headers | jsonify }}.data: The body of the requestThe last expected argument is the expected json response from the Rest API. The
contract will generate with only types and required for all fields.
If you want to validate the values, you need to fill the consts and enums
manually.$fellowshipgeneratesample.json'{"url": "/test", "method": "GET"}'\'{"json": "expected_response"}'gRPCFor gRPC validation, run Fellowship in validate gRPC mode. It takes the same
syntax as validate for REST. But make sure that you only have one type of
contracts in the directory that you validate.To generate gRPC contracts you run Fellowship in generate_grpc mode. It takes
the output directory path as first argument and the proto file to use as a basis
for generation as second argument. It will generate contracts for all services
and all their functions. The contracts will be output to directory given in the
path argument.FeaturesgRPC and REST endpoint contract testing and contract rendering.Future development plans includes to support message-based communicationInstallationfellowshipis available on PyPI. You can install usingpip:$pipinstallfellowshipRunning the Test SuiteIf you havetoxinstalled (perhaps viapip install toxor your
package manager), runningtoxin the directory of your source
checkout will runfellowship’s test suite.ContributingSee how to contribute inCONTRIBUTING.rst.The code and the issues are hosted onGitHub.The project is licensed underBSD-3-Clause.The documentation is hosted onread the docs
Package: felt
Felt is a Python library for estimating path flows on networks where flows are
not directly observable. It is motivated by estimating vehicle flows on highway
networks, but may be applied to other problems.Quick StartInstallationpip install feltExampleWe’d like to estimate path flows on a network. To start we build a model of the
network. The network has two links that merge together onto a single link, and
then diverge again to two links.>>> from felt import Network, Node, Way
>>> network = Network(
...     [
...         Node(1, 0.0, 0.0),
...         Node(2, 1.0, 0.0),
...         Node(3, 2.0, 0.0),
...         Node(4, 3.0, 0.0),
...         Node(5, 0.0, 1.0),
...         Node(6, 3.0, 1.0)
...     ],
...     [
...         Way([1, 2, 3, 4], oneway=True),
...         Way([5, 2], oneway=True),
...         Way([3, 6], oneway=True)
...     ]
... )Now we make a list of all the possible paths on this network. There are two
source nodes: 1 and 5; and there are two sink nodes: 4 and 6. Each source node
is connected with a path to each other sink node, to make a total of four paths.
Our goal is to estimate the flow on each of the four paths.>>> paths = [
...     network.shortest_path(1, 4),
...     network.shortest_path(1, 6),
...     network.shortest_path(5, 4),
...     network.shortest_path(5, 6)
... ]
>>> paths
[Path([1, 2, 3, 4]), Path([1, 2, 3, 6]), Path([5, 2, 3, 4]), Path([5, 2, 3, 6])]To help us with our estimation, we have movement flow observations for three
movements. You can think of movements as sub-sequences of paths, where each path
either has that sub-sequence or not. The movement flow observations for the
three movements are 30, 70, and 40.>>> from felt import Movement
>>> movements = [
...     Movement([..., 1, 2, 3, ...]),
...     Movement([..., 5, 2, 3, ...]),
...     Movement([..., 2, 3, 4, ...])
... ]
>>> movement_flows = [30, 70, 40]Now we can estimate the path flows from our movement flows. Our estimates are
12, 18, 28 and 42.>>> from felt import estimate
>>> path_flows = estimate(paths, movements, movement_flows)
>>> print([round(v) for v in path_flows])
[12, 18, 28, 42]Documentationhttps://felt.readthedocs.io/en/latest/index.html
Package: feltlabs
This code is intended to work closely with Ocean protocol. Algorithms from this code
should run on ocean provider. Training local models and aggregating them into global
model.Entry commands:felt-train
felt-aggregate
felt-exportCommon UsageAfter installing this library you can load models trained using FELT as:fromfeltlabs.modelimportload_model# Load scikit-learn modelmodel=load_model("final-model.json")# Data shape must be: (number_of_samples, number_of_features)data=[[1980,2,2,2,0,0],[1700,3,2,3,1,1],[2100,3,2,3,1,0],]result=model.predict(data)print(result)# Use following line for analytics as mean, std...# result = model.predict(None)Command: felt-exportYou can usefelt-exportfor converting trained models into pickle object:
Resulting file will then contain a pickled object of scikit-learn model.felt-export--input"final-model-House Prices.json"--output"model.pkl"Then you can use the created file as follows:importpicklewithopen('model.pkl','rb')asf:model=pickle.load(object,f)# See the above code example for data definitionmodel.predict(data)
Package: feltpy
FeltPyfeltpyis a lightweight Python package to interact with thepublic APIofFelt.com.InstallationThis package is available in PyPI, and can be installed like so:pipinstallfeltpyOnce installed, import the package withimportfeltpyThis package only requires a few packages, most of which come with a default installation of Python, namely:reosrequestsgeopandasI've only tested this on Python 3.10, but it will presumably work with older version of Python 3!Set-UpAll functions in this package are only set up, currently, to work with Felt'sPersonal Access Tokens, which must be acquired ahead of time. More information on doing so can be found onFelt's API documentation.FeaturesAs of 2023-07-28, this package can use the API to:Create a new mapUpload data as a layer to a map, either from a file, a URL, or a Geopandas GeoDataFrameQuery the current layers, elements, and comments on a mapUpdate layer descriptionsDelete layers and mapsThis package works through a collection offunctionsandclasses.functions, with names such asgetLayers()anddeleteMap(), perform actions, such as those listed aboveclassescan be thought of asobjects, each one representing something that currently exists on Felt, such as aMap, aLayer, aLayer Collection(i.e. all the layers on a map), andDatasets(i.e. what data "powers" a layer - not so useful at the moment)MapandLayeralso havemethodswithin them that allow for easier calling offunctions- for example, a layer could be deleted by either calling the functiondeleteLayer(), or by callingLayer.deleteLayer()Future WorkAs of 2023-07-28, this package doesnotinteract with any API functions that deal with the Felt Style Language. This is out of practicality: the API documentation states that these endpoints might change in the future, and I would rather wait for it to be finalized before devoting time to figuring it outThis package could also be extended to be more "helpful" - for instance, confirming that a layer or map is deleted, or enabling more complex functinos, such as creating a new mapandloading data to itFinally, this package is only set up to work with Felt's Personal Access Tokens - I hope at some point to also integrate with OAuthContributionI welcome comments and pull requests! This is my first Python package, so it is definitely not consistent or pretty or easy to understand - if you have capital-OOpinionson how you'd like to see this change, feel free to let me know here in Github.
Package: felt-upload
felt-uploadWhatFeltis "the best way to work with maps, together".And this is a simple CLI application to upload your files to it from your console.WhyThe Felt API is pretty straightforward, but sometimes you just need a tool to upload a file from a command line and not deal with all the insides.Installpip install felt-uploador you can usepipx:pipx install felt-uploadAPI TokenTo use it you need an API token from Felt. Get yourshere.
You can either pass it directly as--tokenoption or provide as an env variableFELT_TOKEN.
You can check token with theusercommand, which will print out a user for the given token.exportFELT_TOKEN="felt_pat_Ul8HIuHJZuMyxJJ7ZHajj3gBM6KAs4mnnE6f7GiJIPC"felt-uploaduserfelt-uploaduser--token"felt_pat_Ul8HIuHJZuMyxJJ7ZHajj3gBM6KAs4mnnE6f7GiJIPC"All further examples assume you have token set in the env.UsageCreate a map with a single layer and upload your files.felt-uploadmapdata.geojsonYou can also specify a bunch of optional parameters.felt-uploadmap--title"My new map"--layer-name"Great data"data.geojsonKeep in mind,felt-uploadis pretty straighforward and does not know much about different geo file formats, so if you use shapefiles, you need to specify all the files explicitly:felt-uploadmap--title"My new map with shapefiles"shapefile.shxshapefile.shpshapefile.prjshapefile.dbfshapefile.cstOr use a zip archivefelt-uploadmap--title"My new map with zipped shapefiles"shapefile_inside.zipMore use casesMultiple layersCreate multiple layers on a single mapfelt-uploadmap--title"Multilayer"felt-uploadlayer<map-id>--layer-name"My point data"dataset.geojson
felt-uploadlayer<map-id>--layer-name"My other data"dataset-2.geojson
felt-uploadlayer-import<map-id>--layer-name"My layer from url"http://example.com/path-to-dataExisting mapWant to add layer to already existing map?
Grab mapidfrom the url asexplained here, e.g. forhttps://felt.com/map/Untitled-Map-Cwc6EdieQdyXgyPMgDmYBC?loc=37.807,-122.271,14zyou need a part after the map name and before the?:Cwc6EdieQdyXgyPMgDmYBC.