Saravanan666/pypi-org huggingface dataset:
Package: sfrbox-api
SFR Box APIFeaturesTODORequirementsTODOInstallationYou can installSFR Box APIviapipfromPyPI:$pipinstallsfrbox-apiUsagePlease see theCommand-line Referencefor details.ContributingContributions are very welcome.
To learn more, see theContributor Guide.LicenseDistributed under the terms of theMIT license,SFR Box APIis free and open source software.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.CreditsThis project was generated from@cjolowicz'sHypermodern Python Cookiecuttertemplate.
Package: sfreeze
SFreezeA small package for storing serialized python objects persitantly using Amazon AWS S3UsageSECURITY WARNING!!!This library uses the python Pickle module to perform serialization.
Be careful when thawing objects as it can lead to arbitrary code exectuion.Only use this library on objects you trustTo use sfreeze you must have aws cli credentials setup that have access to read and write to the target S3 bucket.Freezing an objectfromsfreezeimports3_freezevariable_to_freeze='some variable'# s3_freeze takes the object, bucket, and optional key# you can also send it other keyword args and they will# get passed to a boto3.client('s3').put_object callobject_id=s3_freeze(variable_to_freeze,'bucket','optional_key')Thawing an objectfrom sfreeze import s3_thaw

# s3_thaw takes the object_id returned from s3_freeze,
# you can also send it other keyword args and they will 
# get passed to a boto3.client('s3').put_object call
thawed_variable = s3_thaw(object_id)
Package: sfrmaker
SFRmakerSFRmaker is a python package for automating construction of stream flow routing networks from hydrography data. Hydrography are input from a polyline shapefile and intersected with a structured grid defined using a shapefile or a FlopyStructuredGridinstance. Attribute data are supplied via.dbffiles (NHDPlus input option) or via specified fields in the hydrography shapefile. Line fragments representing intersections between the flowlines and model grid cells are converted to SFR reaches using the supplied attribute data. MODFLOW-NWT/2005 or MODFLOW-6 SFR package input can then be written, along with shapefiles for visualizing the SFR package dataset.Version 0.11Getting StartedSee theSFRmaker documentationInstallationSee theInstallation InstructionsHow to citeCitations for SFRmakerLeaf, A.T., Fienen, M.N. and Reeves, H.W. (2021), SFRmaker and Linesink-Maker: Rapid Construction of Streamflow Routing Networks from Hydrography Data. Groundwater, 59: 761-771.https://doi.org/10.1111/gwat.13095Leaf, A.T., 2023, Automated construction of Streamflow-Routing networks for MODFLOW—Application in the Mississippi Embayment region: U.S. Geological Survey Scientific Investigations Report 2023–5051, 28 p.,https://doi.org/10.3133/sir20235051.Software/Code citation for SFRmaker (IP-122355):Leaf, A.T., Fienen, M.N. and Reeves, H.W., 2021, SFRmaker version 0.7.1: U.S. Geological Survey Software Release, 29 Jan. 2021,https://doi.org/10.5066/P9U2T031DisclaimerThis software is preliminary or provisional and is subject to revision. It is
being provided to meet the need for timely best science. The software has not
received final approval by the U.S. Geological Survey (USGS). No warranty,
expressed or implied, is made by the USGS or the U.S. Government as to the
functionality of the software and related material nor shall the fact of release
constitute any such warranty. The software is provided on the condition that
neither the USGS nor the U.S. Government shall be held liable for any damages
resulting from the authorized or unauthorized use of the software. It is the responsibility of the user to check the accuracy of the results.Any use of trade, firm, or product names is for descriptive purposes only and does not imply endorsement by the U.S. Government.
Package: sfs
A Python library for creating numercial simulations of sound field synthesis
methods like Wave Field Synthesis (WFS) or Near-Field Compensated Higher Order
Ambisonics (NFC-HOA).Documentation:https://sfs-python.readthedocs.io/Source code and issue tracker:https://github.com/sfstoolbox/sfs-python/License:MIT – see the fileLICENSEfor details.Quick start:Install Python 3, NumPy, SciPy and Matplotlibpython3-mpip install sfs--userCheck out the examples in the documentationMore information about the underlying theory can be found athttps://sfs.readthedocs.io/.
There is also a Sound Field Synthesis Toolbox for Octave/Matlab, seehttps://sfs-matlab.readthedocs.io/.
Package: sfsdk
This repository is part of the SecureFlag Platform.Please refer to the officialdocumentationfor installation instructions and further information.Build TestsPrerequisitesInstallqemu binfmt-support qemu-user-staticon an x86 based system.Such as with aptsudo apt-get install qemu binfmt-support qemu-user-staticRun testsTo run isolated docker test installs for various versions of linux and platforms AMD64/ARM64 use:./tests/docker-build/test-all-build.sh
Package: sf-sdk
顺丰 Python SDK官方SDK只是一个demo，而且数据格式为XML，处理起来并不方便，因此起了这个项目并将数据格式调整为了json格式。使用说明安装pipinstallsf-sdk使用fromsf.apiimportSFsf=SF("clientcode","checkword")sf.order.create_order(clientid,..)
Package: sf-session
sf_sessionMaintain a Salesforce Connection Session.Installation$pipinstallsf_sessionUsageTODOContributingInterested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.Licensesf_sessionwas created by Jarvis Nederlof. It is licensed under the terms of the BSD 3-Clause license.Creditssf_sessionwas created withcookiecutterand thepy-pkgs-cookiecuttertemplate.
Package: sfs-shapwise-feature-selection
SHAPwise Feature Selection (SFS)OverviewSHAPwise Feature Selection (SFS) is a Python library designed to enhance predictive model performance by leveraging SHapley Additive exPlanations (SHAP) values for feature selection. This innovative method systematically evaluates the impact of features on model predictions, identifying and excluding less impactful ones to refine the feature set. The result is not only an improvement in model accuracy but also in interpretability and efficiency.FeaturesSHAP Value Analysis: Utilizes SHAP values to quantify the contribution of each feature towards the model's predictions.Iterative Feature Selection: Employs an iterative process to remove features with low correlation between their SHAP values and their impact on the model outcome.Model Performance Enhancement: Aims to improve model performance by retaining only the most impactful features.Compatibility: Designed for use with PyTorch and FastAI, facilitating easy integration into existing machine learning workflows.Interpretability Improvement: Enhances model interpretability by focusing on features that significantly affect model predictions.Installationpipinstallsfs-shapwise-feature-selectionUsageBasic ExamplefromsfsimportSHAPwiseFeatureSelectorfromsklearn.metricsimportaccuracy_scorefromyour_modelimportYourModelimportpandasaspd# Load your datasetX,y=pd.read_csv("your_dataset.csv").drop("target",axis=1),pd.read_csv("your_dataset.csv")["target"]# Initialize your modelmodel=YourModel()X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.2,random_state=42)# Initialize SHAPwise Feature Selectorsfs_model=SHAPwiseFeatureSelector(model,accuracy_score)# Train your model using the SHAPwise Feature Selection methodsfs_model.fit(X_train,y_train,X_test,y_test)drop_features=sfs_model.sfs_modelmodel=sfs_model.base_estimatorAdvanced ConfigurationRefer to the documentation for advanced configuration options, including setting thresholds for SHAP value correlation and customizing the iterative selection process.DocumentationFor detailed documentation, including API references and advanced usage examples, please visitSFS Documentation.ContributingWe welcome contributions to the SFS project! Please refer to our contribution guidelines for more information on how to report issues, submit pull requests, and more.LicenseSFS is released under the MIT License. See the LICENSE file for more details.AcknowledgmentsThis project was inspired by the work on SHapley Additive exPlanations (SHAP) and aims to bring the power of SHAP values to the realm of feature selection for machine learning models.CitationIf you use SFS in your research, please cite our paper:@article{yourname2024shapwise,
  title={SHAPwise Feature Selection (SFS): Enhancing Predictive Models through Correlation-Based Feature Analysis},
  author={Your Name and Collaborators},
  journal={Journal of Machine Learning Research},
  volume={xx},
  number={xx},
  pages={xx-xx},
  year={2024}
}For further information and support, please open an issue in the GitHub repository.
Package: sfst
Python bindings for SFSTThis is python binding for SFST. Thesfstpython library can be imported and can be used for analysis and generation as explained in the below examples:Installationsfspython library is available at pypi.org. It can be installed as follows:pipinstallsfstImport and initializeimportsfst# Initialize with the compiled sfst.sfst.init('path/to/fst.a'))Initialization is must before doing any operations.Analysisimportsfst# Initialize with the compiled sfst.sfst.init('path/to/fst.a'))# Analyse a string. results are a list of analysis.analysis_results=sfst.analyse("easier")# Returns ['easy<ADJ><comp>'] for example.Generationimportsfst# Initialize with the compiled sfst.sfst.init('path/to/fst.a'))# Generate a string. results are a list of analysis.generate_results=sfst.generate("easy<ADJ><comp>")# Returns ['easier'] for example.
Package: sfst-transduce
sfst-transducePython bindings for SFST focusing on transducer usageA Python library providing bindings for the Stuttgart Finite State Transducer
system with a focus on the usage of compiled and serialized transducers,
excluding code for transducer development and testing, which reduces compile and
runtime dependencies.Should you need theSFST
toolsfor transducer
generation, please take a look at their homepage for installation and usage
instructions.Installationsfst-transduceis available atPyPI:pipinstallsfst-transduceUsageimportsfst_transduce# Create instance from compiled transducertransducer=sfst_transduce.Transducer('path/to/fst.a')# Analysisanalysis_results=transducer.analyse("easier")# Returns ['easy<ADJ><comp>'] for example.# Generate a string. results are a list of analysis.generate_results=transducer.generate("easy<ADJ><comp>")# Returns ['easier'] for example.# Create instance from compiled transducer (compacted serialisation)transducer=sfst_transduce.CompactTransducer('path/to/fst.ca')# Activate output of aligned input and output layertransducer.both_layers=True# Analysistransducer.analyse('easier')# Returns ['easy:i<ADJ>:<><comp>:e<>:r'] for example.Developmentrm-rfbuild;pipinstall-e'.[dev]'Releasescripts/release$NEW_VERSIONgitpush&&gitpush--tagsCreditsTheSFST toolshave been
implemented by Helmut Schmid, Institute for Computational Linguistics,
University of Stuttgart, Germany and they are available under the GNU public
license version 2 or higher.Please cite the following publication if you want to refer to the SFST tools:Schmid, Helmut. "A programming language for finite state transducers." FSMNLP.
Vol. 4002. 2005.pdfThis Python library is a fork of the excellentSFST
adaptationby Santhosh Thottingal, changing
the focus of the Python part.
Package: sfsutils
sfsutilsA KSP SFS savefile parserInstallpip install sfsutilsUsageExample:importsfsutilsdata=sfsutils.parse_savefile("saves/persistent.sfs")# edit datasfsutils.writeout_savefile(data,destination_file="saves/edited.sfs")All documentation is in the docstrings of each function.Available functions are (see docstrings for more info):parse_savefile - Parses an SFS file from stream or filewriteout_savefile - Writes out the parsed data back into the SFS formatNotesThe parsing order of this library is deterministic, but note that this guarantee is provided by Python dictionaries sorting keys by the order of insertion (this is the case since Python 3.6).There is a Cython implementation of this module.
With the Cython implementation, parsing is about 4x as fast, and serialisation is about 2x as fast. The Cython backend will automatically be built and selected if Cython is installed along with a working C compiler at the time when this library is installed. If Cython is not available or the build otherwise fails, the pure Python backend will be installed instead.The backend in use can be checked with sfsutils.BACKEND (possible values: "Python", "Cython").LicenseGPLV3
Package: sfti-net
Pysislab - CRISiSLab Seismometer Network ClientDescriptionThis is a client forCRISiSLab's Seismometer NetworkAPI using WebSockets and MessagePack.Installation$pipinstallpysislabUsageTo list all stations (optionally in CSV format)$pysislab--list--csvTo watch live data in real time for a particular seismometer$pysislab--tail<seismometerid>Or the equivalent in Pythonfrompysislabimportget_sensorsforsensoringet_sensors():print(sensor.id,sensor.secondary_id,sensor.type,sensor.publicLocation,sensor.online,)frompysislabimportSensorTailfordatagraminSensorTail(22):print(datagram.channel,datagram.timestamp,datagram.data)For more examples, see theCLI implementation.See themodels filefor the full list of attributes available on each class.
Package: sftmpl
sftmpl takes a single file as input and uses the built-in string format method
to replace the occurences of brace-enclosed variables by values given on the
command-line.The aim of sftmpl is to simplify the generation of configuration file in
computing protocols by providing a command-line enabled customization of these
configuration files.InstallObtain the distribution file and usepython setup.py installThe source repository ishttps://github.com/pdebuyl/sftmpl.gitand the code may
be obtained via the commandgit clonehttps://github.com/pdebuyl/sftmpl.gitUsesftmpl uses the curly brace named fields defined inPEP 3101.For the following input filemyconfig.txt, you must provide the command-line
options-N,–parameterand–N_steps:# Config for "myprog"
N = {N}
parameter = {parameter}

run {N_steps} stepsThe invocation is as follows when sftmpl is installedsftmpl myconfig.txt -N 10 –parameter 0.1 –N_steps 500and the following result is output to the standard output:# Config for "myprog"
N = 10
parameter = 0.1

run 500 stepsMiscAuthor: Pierre de BuylLicense: Modified BSD (seeLICENSE).
Package: sftpclient
Simple Username/Password based SFTP Client.sftpclientis a simple to use sftp client to connect to remote FTP servers over ssh (SFTP) using username/password combo.Uploads and downloads work with file-handles by default so as to not fill up the working directory with downloaded files when the desire was just to read and parse the data available at the remote server.Default downloads are inbytesmodemode=rb, use anio.TextIOWrapperto read the file as text.Sample usagefromsftpclientimportSFTPClient# create client instance.client=SFTPClient(host=SFTPHOST,username=YOURSFTPUSERNAME,password=YOURSFTPPASSWORD,use_known_hosts=UPTOYOUTODECIDE,)# Uploading files;# 1. open a file (or use a `tempfile.TemporaryFile`).withopen('somefile')asfile_to_upload:# 2. use the `SFTPClient` `upload` method to pass the open file handle to# the remote `destination`.client.upload(file_to_upload,destination='/uploads')# Downloading files;file=client.download('/data/consume.txt',text=True)# use `text=True` when downloading text files, default is `bytes` mode.forlineinfile:# continue with processing the file as desired, or just write it out to# local disk.
Package: sftp-client
# PySFTPClient
Cross-platform SFTP client API aimed at making a more pythonic wrapper around the chilkat sftp library.Requirements:
chilkat python libraryNote: The PySFTPClient requires a license key to the chilkat python library, otherwise, you can use the chilkat trial for 30 days as normal.Basic usage example:from sftp_client import SFTPClient

with SFTPClient(host, username, password, license_key='license_key') as client:
    client.download('./server_path.txt', '~/local_path.txt')
    client.upload('./server_path2.txt', ~/local_path.txt)
    print client.list_directory('./')
Package: sftp-composer
AWS SFTP ComposerRender Secrets for AWS SFTP integrationFree software: MPL2.0Documentation:https://sftp-composer.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.0.1 (2021-05-26)First release on PyPI.
Package: sftpConfigReader
sftpConfigReaderIntrosftpConfigReaderis a tiny package that reads SFTP client configuration
settings stored in*.iniconfiguration file.I created this package for convenience when working on an application that
was using Paramiko SFTP library:http://www.paramiko.org/Example:Suppose your SFTP client configuration file is stored in
/home/johndoe/.sftp/some_sftp_server/config.ini.[sftp]
sftp_host=localhost
port=22
user=john
password=helloJohn
known_hosts=/home/john/.ssh/known_hostsYou want your Python application to access the SFTP connection settings.fromsftpConfigReaderimportread_sftp_configconf_file=r'home/johndoe/.sftp/some_sftp_server/config.ini'settings_dict=read_sftp_config(conf_file,'sftp')If the path to the configuration file and the section name are correct, thensettings_dictvariable is going to contain SFTP settings dictionary.Project GitHub:https://github.com/alv2017/sftp_config_reader
Package: sftpgo-client
sftpgo-clientPython client for theSFTPGoAPIThesftpgo_client.basepackage is automatically generated from theOpenAPI
specificationprovided bySFTPGousingopenapi-python-client.Installationpip install sftpgo-clientExamplesCreating a client:fromsftpgo_clientimportClientclient=Client(base_url="http://localhost:8080/api/v2",user="admin",password="password")In an asyncio environment, use the asynchronous client instead:fromsftpgo_clientimportAsyncClientclient=AsyncClient(base_url="http://localhost:8080/api/v2",user="admin",password="password")Listing users:users=client.get_users()foruserinusers:print(user.username)or with the asynchronous client:users=awaitclient.get_users()foruserinusers:print(user.username)All API endpoints are available in both the synchronous and asynchronous clients.Adding a new user:fromsftpgo_clientimportUseruser=User.from_dict({"username":"user","password":"password","permissions":{"/":["*"]},})client.add_user(json_body=user)DevelopmentYou can fetch the latest version of theSFTPGoOpenAPI specification and
updatesftpgo_client.basewith:./generator/run.shYou can run the tests with:docker-compose up -d
pytest
Package: sftpoeb
About Repository
This Repository for Developer Etax Solution SFTPInstallation
must be use python3.6 ++Change Log0.0.1 (13/06/2023)First Release0.0.2 (13/06/2023)Second Release0.0.3 (14/06/2023)Fixbug0.0.4 (14/06/2023)Fixbug0.0.5 (14/06/2023)Fixbug0.0.6 (14/06/2023)Fixbug0.0.7 (14/06/2023)Fixbug0.0.8 (14/06/2023)Fixbug0.0.9 (14/06/2023)Fixbug0.1.0 (14/06/2023)Fixbug0.1.1 (14/06/2023)Fixbug0.1.2 (15/06/2023)Fixbug0.1.3 (16/06/2023)Process Recovery0.1.4 (16/06/2023)Process Recovery allFixbux variable0.1.5 (16/06/2023)Package-2 S06Recovery S060.1.6 (19/06/2023)Edit Path Package S060.1.7 (19/06/2023)Edit Path Package S060.1.8 (19/06/2023)Edit Path Package S060.1.9 (19/06/2023)Edit permission makedir0.2.1 (19/06/2023)Fetch recovery package 2 (S06) Normally0.2.2 (20/06/2023)Fetch recovery package 2 (S06) Normally again
Package: sftp-py
sftp_py is a Python package for transferring files between remote and local directories using theparamikosftp client. After transfer, downloaded/uploaded files can be optionally deleted from the remote/local source directory. Only files (not directories) are transferred - there is no option to recursively transfer nested directories.InstallationFrom pypi:pip3installsftp_pyFrom GitHub repository:gitclonehttps://github.com/AlexOrlek/sftp_py.gitcdsftp_py
pip3install.Options and usagesftp_py can be used within a Python script as follows:from sftp_py.transfer import RemoteTransferconn = RemoteTransfer([arguments...])To download from a remote server:# Establish connection and download files.# local_path must be a directory# remote_path can be a single file or a directory containing files to be transferredconn=RemoteTransfer(host=host_name,username=user_name,port=22,key=private_key_path)conn.connect()conn.list_remote_dir(remote_path)# inspect directory contentsconn.remote_download(remote_path,local_path,copy_hidden_files=True,copy_symlink_files=True,remove=False)# hidden files (.*) and symlink files are copied by default# remove=True: downloaded files are removed immediately after transfer# remove=False (default): downloaded files are recorded and can be removed later...conn.downloaded_files# conn.downloaded_files records list of downloaded filenamesconn.remove_downloaded()# remove downloaded files# Disconnect once finishedconn.disconnect()To upload to a server:# Code for uploading to a remote server is similar to code for downloading from a remote server...conn=RemoteTransfer(host=host_name,username=user_name,port=22,key=private_key_path)conn.connect()conn.remote_upload(remote_path,local_path,remove=True)# upload and remove uploaded files from local_pathconn.disconnect()LicenseMIT LicenseHistory0.2.0First release on PyPI0.1.0First release, working code
Package: sftpserver
sftpserveris a simple single-threaded SFTP server based on
Paramiko’s SFTPServer.I needed a simple server that could be used as a stub for testing
Python SFTP clients so I whipped out one.InstallationUsingpip:$ [sudo] pip install sftpserverExamples$ sftpserver
Usage: sftpserver [options]
-k/--keyfile should be specified


Options:
  -h, --help            show this help message and exit
  --host=HOST           listen on HOST [default: localhost]
  -p PORT, --port=PORT  listen on PORT [default: 3373]
  -l LEVEL, --level=LEVEL
                        Debug level: WARNING, INFO, DEBUG [default: INFO]
  -k FILE, --keyfile=FILE
                        Path to private key, for example /tmp/test_rsa.key

$ sftpserver -k /tmp/test_rsa.key -l DEBUGGenerating a test private key:$ openssl req -out CSR.csr -new -newkey rsa:2048 -nodes -keyout /tmp/test_rsa.keyConnecting with a Python client to our server:>>> import paramiko
>>> pkey = paramiko.RSAKey.from_private_key_file('/tmp/test_rsa.key')
>>> transport = paramiko.Transport(('localhost', 3373))
>>> transport.connect(username='admin', password='admin', pkey=pkey)
>>> sftp = paramiko.SFTPClient.from_transport(transport)
>>> sftp.listdir('.')
['loop.py', 'stub_sftp.py']
Package: sftpsyncer
Synchronise files piecemeal back and forth between a local cache and a remote
SFTP server.Use caseYou have a client that sometimes needs to syncronise files to and
from an SFTP server.open() a file whether it’s remote or local.
* If the file is available locally, use the local copy.
* If the local file doesn’t exist, download it and then use the local copy.add() files to an upload package, then push() to upload all locally queued
files.This model is simplistic, and will clobber any changes at the other end if
a file with the same name exists. If you want to avoid that, you may be better
off using Git or the like.How to use:import sftpsyncer
from sftpsyncer import syncagent

sagent = syncagent(hostname="remote_sagenth.example.com", host_port="1222",
                username="theuser", key_path="/home/theuser/.sagenth/key",
                local_root="/tmp/cache", remote_root="/upload_target")

# upload local files

sagent.upload_queue.add("myfile.txt")
sagent.upload_queue.add("docs/readme.txt")

sagent.push()  # upload whether or not remote files exist

# auto-get remote files, reading from cache when available

fh1 = sagent.open("myfile.txt")  # file is already local, return local fh
fh2 = sagent.open("remote.txt")  # file is not local, transfer to local cache, return local fh

# exceptions

try:
    fh3 = sagent.open("not_anywhere.txt")
except sftpsyncer.exceptions.FileNotFound as e:
    print "File does not exist on local or remote"

try:
    fh5 = sagent.open("ssh_server_unavailable.txt")
except sftpsyncer.exceptions.ConnectionError as e:
    print "Remote SFTP service appears to be unavailable"